commit ced51a0face785ae9e67925c242d812204a151ac · pci.express/frostium

.gitignore

+675

LICENSE

···

       1
       1
       +
                           GNU GENERAL PUBLIC LICENSE

     

       2
       2
       +
                              Version 3, 29 June 2007

     

       3
       3
       +
       

     

       4
       4
       +
        Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>

     

       5
       5
       +
        Everyone is permitted to copy and distribute verbatim copies

     

       6
       6
       +
        of this license document, but changing it is not allowed.

     

       7
       7
       +
       

     

       8
       8
       +
                                   Preamble

     

       9
       9
       +
       

     

       10
       10
       +
         The GNU General Public License is a free, copyleft license for

     

       11
       11
       +
       software and other kinds of works.

     

       12
       12
       +
       

     

       13
       13
       +
         The licenses for most software and other practical works are designed

     

       14
       14
       +
       to take away your freedom to share and change the works.  By contrast,

     

       15
       15
       +
       the GNU General Public License is intended to guarantee your freedom to

     

       16
       16
       +
       share and change all versions of a program--to make sure it remains free

     

       17
       17
       +
       software for all its users.  We, the Free Software Foundation, use the

     

       18
       18
       +
       GNU General Public License for most of our software; it applies also to

     

       19
       19
       +
       any other work released this way by its authors.  You can apply it to

     

       20
       20
       +
       your programs, too.

     

       21
       21
       +
       

     

       22
       22
       +
         When we speak of free software, we are referring to freedom, not

     

       23
       23
       +
       price.  Our General Public Licenses are designed to make sure that you

     

       24
       24
       +
       have the freedom to distribute copies of free software (and charge for

     

       25
       25
       +
       them if you wish), that you receive source code or can get it if you

     

       26
       26
       +
       want it, that you can change the software or use pieces of it in new

     

       27
       27
       +
       free programs, and that you know you can do these things.

     

       28
       28
       +
       

     

       29
       29
       +
         To protect your rights, we need to prevent others from denying you

     

       30
       30
       +
       these rights or asking you to surrender the rights.  Therefore, you have

     

       31
       31
       +
       certain responsibilities if you distribute copies of the software, or if

     

       32
       32
       +
       you modify it: responsibilities to respect the freedom of others.

     

       33
       33
       +
       

     

       34
       34
       +
         For example, if you distribute copies of such a program, whether

     

       35
       35
       +
       gratis or for a fee, you must pass on to the recipients the same

     

       36
       36
       +
       freedoms that you received.  You must make sure that they, too, receive

     

       37
       37
       +
       or can get the source code.  And you must show them these terms so they

     

       38
       38
       +
       know their rights.

     

       39
       39
       +
       

     

       40
       40
       +
         Developers that use the GNU GPL protect your rights with two steps:

     

       41
       41
       +
       (1) assert copyright on the software, and (2) offer you this License

     

       42
       42
       +
       giving you legal permission to copy, distribute and/or modify it.

     

       43
       43
       +
       

     

       44
       44
       +
         For the developers' and authors' protection, the GPL clearly explains

     

       45
       45
       +
       that there is no warranty for this free software.  For both users' and

     

       46
       46
       +
       authors' sake, the GPL requires that modified versions be marked as

     

       47
       47
       +
       changed, so that their problems will not be attributed erroneously to

     

       48
       48
       +
       authors of previous versions.

     

       49
       49
       +
       

     

       50
       50
       +
         Some devices are designed to deny users access to install or run

     

       51
       51
       +
       modified versions of the software inside them, although the manufacturer

     

       52
       52
       +
       can do so.  This is fundamentally incompatible with the aim of

     

       53
       53
       +
       protecting users' freedom to change the software.  The systematic

     

       54
       54
       +
       pattern of such abuse occurs in the area of products for individuals to

     

       55
       55
       +
       use, which is precisely where it is most unacceptable.  Therefore, we

     

       56
       56
       +
       have designed this version of the GPL to prohibit the practice for those

     

       57
       57
       +
       products.  If such problems arise substantially in other domains, we

     

       58
       58
       +
       stand ready to extend this provision to those domains in future versions

     

       59
       59
       +
       of the GPL, as needed to protect the freedom of users.

     

       60
       60
       +
       

     

       61
       61
       +
         Finally, every program is threatened constantly by software patents.

     

       62
       62
       +
       States should not allow patents to restrict development and use of

     

       63
       63
       +
       software on general-purpose computers, but in those that do, we wish to

     

       64
       64
       +
       avoid the special danger that patents applied to a free program could

     

       65
       65
       +
       make it effectively proprietary.  To prevent this, the GPL assures that

     

       66
       66
       +
       patents cannot be used to render the program non-free.

     

       67
       67
       +
       

     

       68
       68
       +
         The precise terms and conditions for copying, distribution and

     

       69
       69
       +
       modification follow.

     

       70
       70
       +
       

     

       71
       71
       +
                              TERMS AND CONDITIONS

     

       72
       72
       +
       

     

       73
       73
       +
         0. Definitions.

     

       74
       74
       +
       

     

       75
       75
       +
         "This License" refers to version 3 of the GNU General Public License.

     

       76
       76
       +
       

     

       77
       77
       +
         "Copyright" also means copyright-like laws that apply to other kinds of

     

       78
       78
       +
       works, such as semiconductor masks.

     

       79
       79
       +
       

     

       80
       80
       +
         "The Program" refers to any copyrightable work licensed under this

     

       81
       81
       +
       License.  Each licensee is addressed as "you".  "Licensees" and

     

       82
       82
       +
       "recipients" may be individuals or organizations.

     

       83
       83
       +
       

     

       84
       84
       +
         To "modify" a work means to copy from or adapt all or part of the work

     

       85
       85
       +
       in a fashion requiring copyright permission, other than the making of an

     

       86
       86
       +
       exact copy.  The resulting work is called a "modified version" of the

     

       87
       87
       +
       earlier work or a work "based on" the earlier work.

     

       88
       88
       +
       

     

       89
       89
       +
         A "covered work" means either the unmodified Program or a work based

     

       90
       90
       +
       on the Program.

     

       91
       91
       +
       

     

       92
       92
       +
         To "propagate" a work means to do anything with it that, without

     

       93
       93
       +
       permission, would make you directly or secondarily liable for

     

       94
       94
       +
       infringement under applicable copyright law, except executing it on a

     

       95
       95
       +
       computer or modifying a private copy.  Propagation includes copying,

     

       96
       96
       +
       distribution (with or without modification), making available to the

     

       97
       97
       +
       public, and in some countries other activities as well.

     

       98
       98
       +
       

     

       99
       99
       +
         To "convey" a work means any kind of propagation that enables other

     

       100
       100
       +
       parties to make or receive copies.  Mere interaction with a user through

     

       101
       101
       +
       a computer network, with no transfer of a copy, is not conveying.

     

       102
       102
       +
       

     

       103
       103
       +
         An interactive user interface displays "Appropriate Legal Notices"

     

       104
       104
       +
       to the extent that it includes a convenient and prominently visible

     

       105
       105
       +
       feature that (1) displays an appropriate copyright notice, and (2)

     

       106
       106
       +
       tells the user that there is no warranty for the work (except to the

     

       107
       107
       +
       extent that warranties are provided), that licensees may convey the

     

       108
       108
       +
       work under this License, and how to view a copy of this License.  If

     

       109
       109
       +
       the interface presents a list of user commands or options, such as a

     

       110
       110
       +
       menu, a prominent item in the list meets this criterion.

     

       111
       111
       +
       

     

       112
       112
       +
         1. Source Code.

     

       113
       113
       +
       

     

       114
       114
       +
         The "source code" for a work means the preferred form of the work

     

       115
       115
       +
       for making modifications to it.  "Object code" means any non-source

     

       116
       116
       +
       form of a work.

     

       117
       117
       +
       

     

       118
       118
       +
         A "Standard Interface" means an interface that either is an official

     

       119
       119
       +
       standard defined by a recognized standards body, or, in the case of

     

       120
       120
       +
       interfaces specified for a particular programming language, one that

     

       121
       121
       +
       is widely used among developers working in that language.

     

       122
       122
       +
       

     

       123
       123
       +
         The "System Libraries" of an executable work include anything, other

     

       124
       124
       +
       than the work as a whole, that (a) is included in the normal form of

     

       125
       125
       +
       packaging a Major Component, but which is not part of that Major

     

       126
       126
       +
       Component, and (b) serves only to enable use of the work with that

     

       127
       127
       +
       Major Component, or to implement a Standard Interface for which an

     

       128
       128
       +
       implementation is available to the public in source code form.  A

     

       129
       129
       +
       "Major Component", in this context, means a major essential component

     

       130
       130
       +
       (kernel, window system, and so on) of the specific operating system

     

       131
       131
       +
       (if any) on which the executable work runs, or a compiler used to

     

       132
       132
       +
       produce the work, or an object code interpreter used to run it.

     

       133
       133
       +
       

     

       134
       134
       +
         The "Corresponding Source" for a work in object code form means all

     

       135
       135
       +
       the source code needed to generate, install, and (for an executable

     

       136
       136
       +
       work) run the object code and to modify the work, including scripts to

     

       137
       137
       +
       control those activities.  However, it does not include the work's

     

       138
       138
       +
       System Libraries, or general-purpose tools or generally available free

     

       139
       139
       +
       programs which are used unmodified in performing those activities but

     

       140
       140
       +
       which are not part of the work.  For example, Corresponding Source

     

       141
       141
       +
       includes interface definition files associated with source files for

     

       142
       142
       +
       the work, and the source code for shared libraries and dynamically

     

       143
       143
       +
       linked subprograms that the work is specifically designed to require,

     

       144
       144
       +
       such as by intimate data communication or control flow between those

     

       145
       145
       +
       subprograms and other parts of the work.

     

       146
       146
       +
       

     

       147
       147
       +
         The Corresponding Source need not include anything that users

     

       148
       148
       +
       can regenerate automatically from other parts of the Corresponding

     

       149
       149
       +
       Source.

     

       150
       150
       +
       

     

       151
       151
       +
         The Corresponding Source for a work in source code form is that

     

       152
       152
       +
       same work.

     

       153
       153
       +
       

     

       154
       154
       +
         2. Basic Permissions.

     

       155
       155
       +
       

     

       156
       156
       +
         All rights granted under this License are granted for the term of

     

       157
       157
       +
       copyright on the Program, and are irrevocable provided the stated

     

       158
       158
       +
       conditions are met.  This License explicitly affirms your unlimited

     

       159
       159
       +
       permission to run the unmodified Program.  The output from running a

     

       160
       160
       +
       covered work is covered by this License only if the output, given its

     

       161
       161
       +
       content, constitutes a covered work.  This License acknowledges your

     

       162
       162
       +
       rights of fair use or other equivalent, as provided by copyright law.

     

       163
       163
       +
       

     

       164
       164
       +
         You may make, run and propagate covered works that you do not

     

       165
       165
       +
       convey, without conditions so long as your license otherwise remains

     

       166
       166
       +
       in force.  You may convey covered works to others for the sole purpose

     

       167
       167
       +
       of having them make modifications exclusively for you, or provide you

     

       168
       168
       +
       with facilities for running those works, provided that you comply with

     

       169
       169
       +
       the terms of this License in conveying all material for which you do

     

       170
       170
       +
       not control copyright.  Those thus making or running the covered works

     

       171
       171
       +
       for you must do so exclusively on your behalf, under your direction

     

       172
       172
       +
       and control, on terms that prohibit them from making any copies of

     

       173
       173
       +
       your copyrighted material outside their relationship with you.

     

       174
       174
       +
       

     

       175
       175
       +
         Conveying under any other circumstances is permitted solely under

     

       176
       176
       +
       the conditions stated below.  Sublicensing is not allowed; section 10

     

       177
       177
       +
       makes it unnecessary.

     

       178
       178
       +
       

     

       179
       179
       +
         3. Protecting Users' Legal Rights From Anti-Circumvention Law.

     

       180
       180
       +
       

     

       181
       181
       +
         No covered work shall be deemed part of an effective technological

     

       182
       182
       +
       measure under any applicable law fulfilling obligations under article

     

       183
       183
       +
       11 of the WIPO copyright treaty adopted on 20 December 1996, or

     

       184
       184
       +
       similar laws prohibiting or restricting circumvention of such

     

       185
       185
       +
       measures.

     

       186
       186
       +
       

     

       187
       187
       +
         When you convey a covered work, you waive any legal power to forbid

     

       188
       188
       +
       circumvention of technological measures to the extent such circumvention

     

       189
       189
       +
       is effected by exercising rights under this License with respect to

     

       190
       190
       +
       the covered work, and you disclaim any intention to limit operation or

     

       191
       191
       +
       modification of the work as a means of enforcing, against the work's

     

       192
       192
       +
       users, your or third parties' legal rights to forbid circumvention of

     

       193
       193
       +
       technological measures.

     

       194
       194
       +
       

     

       195
       195
       +
         4. Conveying Verbatim Copies.

     

       196
       196
       +
       

     

       197
       197
       +
         You may convey verbatim copies of the Program's source code as you

     

       198
       198
       +
       receive it, in any medium, provided that you conspicuously and

     

       199
       199
       +
       appropriately publish on each copy an appropriate copyright notice;

     

       200
       200
       +
       keep intact all notices stating that this License and any

     

       201
       201
       +
       non-permissive terms added in accord with section 7 apply to the code;

     

       202
       202
       +
       keep intact all notices of the absence of any warranty; and give all

     

       203
       203
       +
       recipients a copy of this License along with the Program.

     

       204
       204
       +
       

     

       205
       205
       +
         You may charge any price or no price for each copy that you convey,

     

       206
       206
       +
       and you may offer support or warranty protection for a fee.

     

       207
       207
       +
       

     

       208
       208
       +
         5. Conveying Modified Source Versions.

     

       209
       209
       +
       

     

       210
       210
       +
         You may convey a work based on the Program, or the modifications to

     

       211
       211
       +
       produce it from the Program, in the form of source code under the

     

       212
       212
       +
       terms of section 4, provided that you also meet all of these conditions:

     

       213
       213
       +
       

     

       214
       214
       +
           a) The work must carry prominent notices stating that you modified

     

       215
       215
       +
           it, and giving a relevant date.

     

       216
       216
       +
       

     

       217
       217
       +
           b) The work must carry prominent notices stating that it is

     

       218
       218
       +
           released under this License and any conditions added under section

     

       219
       219
       +
           7.  This requirement modifies the requirement in section 4 to

     

       220
       220
       +
           "keep intact all notices".

     

       221
       221
       +
       

     

       222
       222
       +
           c) You must license the entire work, as a whole, under this

     

       223
       223
       +
           License to anyone who comes into possession of a copy.  This

     

       224
       224
       +
           License will therefore apply, along with any applicable section 7

     

       225
       225
       +
           additional terms, to the whole of the work, and all its parts,

     

       226
       226
       +
           regardless of how they are packaged.  This License gives no

     

       227
       227
       +
           permission to license the work in any other way, but it does not

     

       228
       228
       +
           invalidate such permission if you have separately received it.

     

       229
       229
       +
       

     

       230
       230
       +
           d) If the work has interactive user interfaces, each must display

     

       231
       231
       +
           Appropriate Legal Notices; however, if the Program has interactive

     

       232
       232
       +
           interfaces that do not display Appropriate Legal Notices, your

     

       233
       233
       +
           work need not make them do so.

     

       234
       234
       +
       

     

       235
       235
       +
         A compilation of a covered work with other separate and independent

     

       236
       236
       +
       works, which are not by their nature extensions of the covered work,

     

       237
       237
       +
       and which are not combined with it such as to form a larger program,

     

       238
       238
       +
       in or on a volume of a storage or distribution medium, is called an

     

       239
       239
       +
       "aggregate" if the compilation and its resulting copyright are not

     

       240
       240
       +
       used to limit the access or legal rights of the compilation's users

     

       241
       241
       +
       beyond what the individual works permit.  Inclusion of a covered work

     

       242
       242
       +
       in an aggregate does not cause this License to apply to the other

     

       243
       243
       +
       parts of the aggregate.

     

       244
       244
       +
       

     

       245
       245
       +
         6. Conveying Non-Source Forms.

     

       246
       246
       +
       

     

       247
       247
       +
         You may convey a covered work in object code form under the terms

     

       248
       248
       +
       of sections 4 and 5, provided that you also convey the

     

       249
       249
       +
       machine-readable Corresponding Source under the terms of this License,

     

       250
       250
       +
       in one of these ways:

     

       251
       251
       +
       

     

       252
       252
       +
           a) Convey the object code in, or embodied in, a physical product

     

       253
       253
       +
           (including a physical distribution medium), accompanied by the

     

       254
       254
       +
           Corresponding Source fixed on a durable physical medium

     

       255
       255
       +
           customarily used for software interchange.

     

       256
       256
       +
       

     

       257
       257
       +
           b) Convey the object code in, or embodied in, a physical product

     

       258
       258
       +
           (including a physical distribution medium), accompanied by a

     

       259
       259
       +
           written offer, valid for at least three years and valid for as

     

       260
       260
       +
           long as you offer spare parts or customer support for that product

     

       261
       261
       +
           model, to give anyone who possesses the object code either (1) a

     

       262
       262
       +
           copy of the Corresponding Source for all the software in the

     

       263
       263
       +
           product that is covered by this License, on a durable physical

     

       264
       264
       +
           medium customarily used for software interchange, for a price no

     

       265
       265
       +
           more than your reasonable cost of physically performing this

     

       266
       266
       +
           conveying of source, or (2) access to copy the

     

       267
       267
       +
           Corresponding Source from a network server at no charge.

     

       268
       268
       +
       

     

       269
       269
       +
           c) Convey individual copies of the object code with a copy of the

     

       270
       270
       +
           written offer to provide the Corresponding Source.  This

     

       271
       271
       +
           alternative is allowed only occasionally and noncommercially, and

     

       272
       272
       +
           only if you received the object code with such an offer, in accord

     

       273
       273
       +
           with subsection 6b.

     

       274
       274
       +
       

     

       275
       275
       +
           d) Convey the object code by offering access from a designated

     

       276
       276
       +
           place (gratis or for a charge), and offer equivalent access to the

     

       277
       277
       +
           Corresponding Source in the same way through the same place at no

     

       278
       278
       +
           further charge.  You need not require recipients to copy the

     

       279
       279
       +
           Corresponding Source along with the object code.  If the place to

     

       280
       280
       +
           copy the object code is a network server, the Corresponding Source

     

       281
       281
       +
           may be on a different server (operated by you or a third party)

     

       282
       282
       +
           that supports equivalent copying facilities, provided you maintain

     

       283
       283
       +
           clear directions next to the object code saying where to find the

     

       284
       284
       +
           Corresponding Source.  Regardless of what server hosts the

     

       285
       285
       +
           Corresponding Source, you remain obligated to ensure that it is

     

       286
       286
       +
           available for as long as needed to satisfy these requirements.

     

       287
       287
       +
       

     

       288
       288
       +
           e) Convey the object code using peer-to-peer transmission, provided

     

       289
       289
       +
           you inform other peers where the object code and Corresponding

     

       290
       290
       +
           Source of the work are being offered to the general public at no

     

       291
       291
       +
           charge under subsection 6d.

     

       292
       292
       +
       

     

       293
       293
       +
         A separable portion of the object code, whose source code is excluded

     

       294
       294
       +
       from the Corresponding Source as a System Library, need not be

     

       295
       295
       +
       included in conveying the object code work.

     

       296
       296
       +
       

     

       297
       297
       +
         A "User Product" is either (1) a "consumer product", which means any

     

       298
       298
       +
       tangible personal property which is normally used for personal, family,

     

       299
       299
       +
       or household purposes, or (2) anything designed or sold for incorporation

     

       300
       300
       +
       into a dwelling.  In determining whether a product is a consumer product,

     

       301
       301
       +
       doubtful cases shall be resolved in favor of coverage.  For a particular

     

       302
       302
       +
       product received by a particular user, "normally used" refers to a

     

       303
       303
       +
       typical or common use of that class of product, regardless of the status

     

       304
       304
       +
       of the particular user or of the way in which the particular user

     

       305
       305
       +
       actually uses, or expects or is expected to use, the product.  A product

     

       306
       306
       +
       is a consumer product regardless of whether the product has substantial

     

       307
       307
       +
       commercial, industrial or non-consumer uses, unless such uses represent

     

       308
       308
       +
       the only significant mode of use of the product.

     

       309
       309
       +
       

     

       310
       310
       +
         "Installation Information" for a User Product means any methods,

     

       311
       311
       +
       procedures, authorization keys, or other information required to install

     

       312
       312
       +
       and execute modified versions of a covered work in that User Product from

     

       313
       313
       +
       a modified version of its Corresponding Source.  The information must

     

       314
       314
       +
       suffice to ensure that the continued functioning of the modified object

     

       315
       315
       +
       code is in no case prevented or interfered with solely because

     

       316
       316
       +
       modification has been made.

     

       317
       317
       +
       

     

       318
       318
       +
         If you convey an object code work under this section in, or with, or

     

       319
       319
       +
       specifically for use in, a User Product, and the conveying occurs as

     

       320
       320
       +
       part of a transaction in which the right of possession and use of the

     

       321
       321
       +
       User Product is transferred to the recipient in perpetuity or for a

     

       322
       322
       +
       fixed term (regardless of how the transaction is characterized), the

     

       323
       323
       +
       Corresponding Source conveyed under this section must be accompanied

     

       324
       324
       +
       by the Installation Information.  But this requirement does not apply

     

       325
       325
       +
       if neither you nor any third party retains the ability to install

     

       326
       326
       +
       modified object code on the User Product (for example, the work has

     

       327
       327
       +
       been installed in ROM).

     

       328
       328
       +
       

     

       329
       329
       +
         The requirement to provide Installation Information does not include a

     

       330
       330
       +
       requirement to continue to provide support service, warranty, or updates

     

       331
       331
       +
       for a work that has been modified or installed by the recipient, or for

     

       332
       332
       +
       the User Product in which it has been modified or installed.  Access to a

     

       333
       333
       +
       network may be denied when the modification itself materially and

     

       334
       334
       +
       adversely affects the operation of the network or violates the rules and

     

       335
       335
       +
       protocols for communication across the network.

     

       336
       336
       +
       

     

       337
       337
       +
         Corresponding Source conveyed, and Installation Information provided,

     

       338
       338
       +
       in accord with this section must be in a format that is publicly

     

       339
       339
       +
       documented (and with an implementation available to the public in

     

       340
       340
       +
       source code form), and must require no special password or key for

     

       341
       341
       +
       unpacking, reading or copying.

     

       342
       342
       +
       

     

       343
       343
       +
         7. Additional Terms.

     

       344
       344
       +
       

     

       345
       345
       +
         "Additional permissions" are terms that supplement the terms of this

     

       346
       346
       +
       License by making exceptions from one or more of its conditions.

     

       347
       347
       +
       Additional permissions that are applicable to the entire Program shall

     

       348
       348
       +
       be treated as though they were included in this License, to the extent

     

       349
       349
       +
       that they are valid under applicable law.  If additional permissions

     

       350
       350
       +
       apply only to part of the Program, that part may be used separately

     

       351
       351
       +
       under those permissions, but the entire Program remains governed by

     

       352
       352
       +
       this License without regard to the additional permissions.

     

       353
       353
       +
       

     

       354
       354
       +
         When you convey a copy of a covered work, you may at your option

     

       355
       355
       +
       remove any additional permissions from that copy, or from any part of

     

       356
       356
       +
       it.  (Additional permissions may be written to require their own

     

       357
       357
       +
       removal in certain cases when you modify the work.)  You may place

     

       358
       358
       +
       additional permissions on material, added by you to a covered work,

     

       359
       359
       +
       for which you have or can give appropriate copyright permission.

     

       360
       360
       +
       

     

       361
       361
       +
         Notwithstanding any other provision of this License, for material you

     

       362
       362
       +
       add to a covered work, you may (if authorized by the copyright holders of

     

       363
       363
       +
       that material) supplement the terms of this License with terms:

     

       364
       364
       +
       

     

       365
       365
       +
           a) Disclaiming warranty or limiting liability differently from the

     

       366
       366
       +
           terms of sections 15 and 16 of this License; or

     

       367
       367
       +
       

     

       368
       368
       +
           b) Requiring preservation of specified reasonable legal notices or

     

       369
       369
       +
           author attributions in that material or in the Appropriate Legal

     

       370
       370
       +
           Notices displayed by works containing it; or

     

       371
       371
       +
       

     

       372
       372
       +
           c) Prohibiting misrepresentation of the origin of that material, or

     

       373
       373
       +
           requiring that modified versions of such material be marked in

     

       374
       374
       +
           reasonable ways as different from the original version; or

     

       375
       375
       +
       

     

       376
       376
       +
           d) Limiting the use for publicity purposes of names of licensors or

     

       377
       377
       +
           authors of the material; or

     

       378
       378
       +
       

     

       379
       379
       +
           e) Declining to grant rights under trademark law for use of some

     

       380
       380
       +
           trade names, trademarks, or service marks; or

     

       381
       381
       +
       

     

       382
       382
       +
           f) Requiring indemnification of licensors and authors of that

     

       383
       383
       +
           material by anyone who conveys the material (or modified versions of

     

       384
       384
       +
           it) with contractual assumptions of liability to the recipient, for

     

       385
       385
       +
           any liability that these contractual assumptions directly impose on

     

       386
       386
       +
           those licensors and authors.

     

       387
       387
       +
       

     

       388
       388
       +
         All other non-permissive additional terms are considered "further

     

       389
       389
       +
       restrictions" within the meaning of section 10.  If the Program as you

     

       390
       390
       +
       received it, or any part of it, contains a notice stating that it is

     

       391
       391
       +
       governed by this License along with a term that is a further

     

       392
       392
       +
       restriction, you may remove that term.  If a license document contains

     

       393
       393
       +
       a further restriction but permits relicensing or conveying under this

     

       394
       394
       +
       License, you may add to a covered work material governed by the terms

     

       395
       395
       +
       of that license document, provided that the further restriction does

     

       396
       396
       +
       not survive such relicensing or conveying.

     

       397
       397
       +
       

     

       398
       398
       +
         If you add terms to a covered work in accord with this section, you

     

       399
       399
       +
       must place, in the relevant source files, a statement of the

     

       400
       400
       +
       additional terms that apply to those files, or a notice indicating

     

       401
       401
       +
       where to find the applicable terms.

     

       402
       402
       +
       

     

       403
       403
       +
         Additional terms, permissive or non-permissive, may be stated in the

     

       404
       404
       +
       form of a separately written license, or stated as exceptions;

     

       405
       405
       +
       the above requirements apply either way.

     

       406
       406
       +
       

     

       407
       407
       +
         8. Termination.

     

       408
       408
       +
       

     

       409
       409
       +
         You may not propagate or modify a covered work except as expressly

     

       410
       410
       +
       provided under this License.  Any attempt otherwise to propagate or

     

       411
       411
       +
       modify it is void, and will automatically terminate your rights under

     

       412
       412
       +
       this License (including any patent licenses granted under the third

     

       413
       413
       +
       paragraph of section 11).

     

       414
       414
       +
       

     

       415
       415
       +
         However, if you cease all violation of this License, then your

     

       416
       416
       +
       license from a particular copyright holder is reinstated (a)

     

       417
       417
       +
       provisionally, unless and until the copyright holder explicitly and

     

       418
       418
       +
       finally terminates your license, and (b) permanently, if the copyright

     

       419
       419
       +
       holder fails to notify you of the violation by some reasonable means

     

       420
       420
       +
       prior to 60 days after the cessation.

     

       421
       421
       +
       

     

       422
       422
       +
         Moreover, your license from a particular copyright holder is

     

       423
       423
       +
       reinstated permanently if the copyright holder notifies you of the

     

       424
       424
       +
       violation by some reasonable means, this is the first time you have

     

       425
       425
       +
       received notice of violation of this License (for any work) from that

     

       426
       426
       +
       copyright holder, and you cure the violation prior to 30 days after

     

       427
       427
       +
       your receipt of the notice.

     

       428
       428
       +
       

     

       429
       429
       +
         Termination of your rights under this section does not terminate the

     

       430
       430
       +
       licenses of parties who have received copies or rights from you under

     

       431
       431
       +
       this License.  If your rights have been terminated and not permanently

     

       432
       432
       +
       reinstated, you do not qualify to receive new licenses for the same

     

       433
       433
       +
       material under section 10.

     

       434
       434
       +
       

     

       435
       435
       +
         9. Acceptance Not Required for Having Copies.

     

       436
       436
       +
       

     

       437
       437
       +
         You are not required to accept this License in order to receive or

     

       438
       438
       +
       run a copy of the Program.  Ancillary propagation of a covered work

     

       439
       439
       +
       occurring solely as a consequence of using peer-to-peer transmission

     

       440
       440
       +
       to receive a copy likewise does not require acceptance.  However,

     

       441
       441
       +
       nothing other than this License grants you permission to propagate or

     

       442
       442
       +
       modify any covered work.  These actions infringe copyright if you do

     

       443
       443
       +
       not accept this License.  Therefore, by modifying or propagating a

     

       444
       444
       +
       covered work, you indicate your acceptance of this License to do so.

     

       445
       445
       +
       

     

       446
       446
       +
         10. Automatic Licensing of Downstream Recipients.

     

       447
       447
       +
       

     

       448
       448
       +
         Each time you convey a covered work, the recipient automatically

     

       449
       449
       +
       receives a license from the original licensors, to run, modify and

     

       450
       450
       +
       propagate that work, subject to this License.  You are not responsible

     

       451
       451
       +
       for enforcing compliance by third parties with this License.

     

       452
       452
       +
       

     

       453
       453
       +
         An "entity transaction" is a transaction transferring control of an

     

       454
       454
       +
       organization, or substantially all assets of one, or subdividing an

     

       455
       455
       +
       organization, or merging organizations.  If propagation of a covered

     

       456
       456
       +
       work results from an entity transaction, each party to that

     

       457
       457
       +
       transaction who receives a copy of the work also receives whatever

     

       458
       458
       +
       licenses to the work the party's predecessor in interest had or could

     

       459
       459
       +
       give under the previous paragraph, plus a right to possession of the

     

       460
       460
       +
       Corresponding Source of the work from the predecessor in interest, if

     

       461
       461
       +
       the predecessor has it or can get it with reasonable efforts.

     

       462
       462
       +
       

     

       463
       463
       +
         You may not impose any further restrictions on the exercise of the

     

       464
       464
       +
       rights granted or affirmed under this License.  For example, you may

     

       465
       465
       +
       not impose a license fee, royalty, or other charge for exercise of

     

       466
       466
       +
       rights granted under this License, and you may not initiate litigation

     

       467
       467
       +
       (including a cross-claim or counterclaim in a lawsuit) alleging that

     

       468
       468
       +
       any patent claim is infringed by making, using, selling, offering for

     

       469
       469
       +
       sale, or importing the Program or any portion of it.

     

       470
       470
       +
       

     

       471
       471
       +
         11. Patents.

     

       472
       472
       +
       

     

       473
       473
       +
         A "contributor" is a copyright holder who authorizes use under this

     

       474
       474
       +
       License of the Program or a work on which the Program is based.  The

     

       475
       475
       +
       work thus licensed is called the contributor's "contributor version".

     

       476
       476
       +
       

     

       477
       477
       +
         A contributor's "essential patent claims" are all patent claims

     

       478
       478
       +
       owned or controlled by the contributor, whether already acquired or

     

       479
       479
       +
       hereafter acquired, that would be infringed by some manner, permitted

     

       480
       480
       +
       by this License, of making, using, or selling its contributor version,

     

       481
       481
       +
       but do not include claims that would be infringed only as a

     

       482
       482
       +
       consequence of further modification of the contributor version.  For

     

       483
       483
       +
       purposes of this definition, "control" includes the right to grant

     

       484
       484
       +
       patent sublicenses in a manner consistent with the requirements of

     

       485
       485
       +
       this License.

     

       486
       486
       +
       

     

       487
       487
       +
         Each contributor grants you a non-exclusive, worldwide, royalty-free

     

       488
       488
       +
       patent license under the contributor's essential patent claims, to

     

       489
       489
       +
       make, use, sell, offer for sale, import and otherwise run, modify and

     

       490
       490
       +
       propagate the contents of its contributor version.

     

       491
       491
       +
       

     

       492
       492
       +
         In the following three paragraphs, a "patent license" is any express

     

       493
       493
       +
       agreement or commitment, however denominated, not to enforce a patent

     

       494
       494
       +
       (such as an express permission to practice a patent or covenant not to

     

       495
       495
       +
       sue for patent infringement).  To "grant" such a patent license to a

     

       496
       496
       +
       party means to make such an agreement or commitment not to enforce a

     

       497
       497
       +
       patent against the party.

     

       498
       498
       +
       

     

       499
       499
       +
         If you convey a covered work, knowingly relying on a patent license,

     

       500
       500
       +
       and the Corresponding Source of the work is not available for anyone

     

       501
       501
       +
       to copy, free of charge and under the terms of this License, through a

     

       502
       502
       +
       publicly available network server or other readily accessible means,

     

       503
       503
       +
       then you must either (1) cause the Corresponding Source to be so

     

       504
       504
       +
       available, or (2) arrange to deprive yourself of the benefit of the

     

       505
       505
       +
       patent license for this particular work, or (3) arrange, in a manner

     

       506
       506
       +
       consistent with the requirements of this License, to extend the patent

     

       507
       507
       +
       license to downstream recipients.  "Knowingly relying" means you have

     

       508
       508
       +
       actual knowledge that, but for the patent license, your conveying the

     

       509
       509
       +
       covered work in a country, or your recipient's use of the covered work

     

       510
       510
       +
       in a country, would infringe one or more identifiable patents in that

     

       511
       511
       +
       country that you have reason to believe are valid.

     

       512
       512
       +
       

     

       513
       513
       +
         If, pursuant to or in connection with a single transaction or

     

       514
       514
       +
       arrangement, you convey, or propagate by procuring conveyance of, a

     

       515
       515
       +
       covered work, and grant a patent license to some of the parties

     

       516
       516
       +
       receiving the covered work authorizing them to use, propagate, modify

     

       517
       517
       +
       or convey a specific copy of the covered work, then the patent license

     

       518
       518
       +
       you grant is automatically extended to all recipients of the covered

     

       519
       519
       +
       work and works based on it.

     

       520
       520
       +
       

     

       521
       521
       +
         A patent license is "discriminatory" if it does not include within

     

       522
       522
       +
       the scope of its coverage, prohibits the exercise of, or is

     

       523
       523
       +
       conditioned on the non-exercise of one or more of the rights that are

     

       524
       524
       +
       specifically granted under this License.  You may not convey a covered

     

       525
       525
       +
       work if you are a party to an arrangement with a third party that is

     

       526
       526
       +
       in the business of distributing software, under which you make payment

     

       527
       527
       +
       to the third party based on the extent of your activity of conveying

     

       528
       528
       +
       the work, and under which the third party grants, to any of the

     

       529
       529
       +
       parties who would receive the covered work from you, a discriminatory

     

       530
       530
       +
       patent license (a) in connection with copies of the covered work

     

       531
       531
       +
       conveyed by you (or copies made from those copies), or (b) primarily

     

       532
       532
       +
       for and in connection with specific products or compilations that

     

       533
       533
       +
       contain the covered work, unless you entered into that arrangement,

     

       534
       534
       +
       or that patent license was granted, prior to 28 March 2007.

     

       535
       535
       +
       

     

       536
       536
       +
         Nothing in this License shall be construed as excluding or limiting

     

       537
       537
       +
       any implied license or other defenses to infringement that may

     

       538
       538
       +
       otherwise be available to you under applicable patent law.

     

       539
       539
       +
       

     

       540
       540
       +
         12. No Surrender of Others' Freedom.

     

       541
       541
       +
       

     

       542
       542
       +
         If conditions are imposed on you (whether by court order, agreement or

     

       543
       543
       +
       otherwise) that contradict the conditions of this License, they do not

     

       544
       544
       +
       excuse you from the conditions of this License.  If you cannot convey a

     

       545
       545
       +
       covered work so as to satisfy simultaneously your obligations under this

     

       546
       546
       +
       License and any other pertinent obligations, then as a consequence you may

     

       547
       547
       +
       not convey it at all.  For example, if you agree to terms that obligate you

     

       548
       548
       +
       to collect a royalty for further conveying from those to whom you convey

     

       549
       549
       +
       the Program, the only way you could satisfy both those terms and this

     

       550
       550
       +
       License would be to refrain entirely from conveying the Program.

     

       551
       551
       +
       

     

       552
       552
       +
         13. Use with the GNU Affero General Public License.

     

       553
       553
       +
       

     

       554
       554
       +
         Notwithstanding any other provision of this License, you have

     

       555
       555
       +
       permission to link or combine any covered work with a work licensed

     

       556
       556
       +
       under version 3 of the GNU Affero General Public License into a single

     

       557
       557
       +
       combined work, and to convey the resulting work.  The terms of this

     

       558
       558
       +
       License will continue to apply to the part which is the covered work,

     

       559
       559
       +
       but the special requirements of the GNU Affero General Public License,

     

       560
       560
       +
       section 13, concerning interaction through a network will apply to the

     

       561
       561
       +
       combination as such.

     

       562
       562
       +
       

     

       563
       563
       +
         14. Revised Versions of this License.

     

       564
       564
       +
       

     

       565
       565
       +
         The Free Software Foundation may publish revised and/or new versions of

     

       566
       566
       +
       the GNU General Public License from time to time.  Such new versions will

     

       567
       567
       +
       be similar in spirit to the present version, but may differ in detail to

     

       568
       568
       +
       address new problems or concerns.

     

       569
       569
       +
       

     

       570
       570
       +
         Each version is given a distinguishing version number.  If the

     

       571
       571
       +
       Program specifies that a certain numbered version of the GNU General

     

       572
       572
       +
       Public License "or any later version" applies to it, you have the

     

       573
       573
       +
       option of following the terms and conditions either of that numbered

     

       574
       574
       +
       version or of any later version published by the Free Software

     

       575
       575
       +
       Foundation.  If the Program does not specify a version number of the

     

       576
       576
       +
       GNU General Public License, you may choose any version ever published

     

       577
       577
       +
       by the Free Software Foundation.

     

       578
       578
       +
       

     

       579
       579
       +
         If the Program specifies that a proxy can decide which future

     

       580
       580
       +
       versions of the GNU General Public License can be used, that proxy's

     

       581
       581
       +
       public statement of acceptance of a version permanently authorizes you

     

       582
       582
       +
       to choose that version for the Program.

     

       583
       583
       +
       

     

       584
       584
       +
         Later license versions may give you additional or different

     

       585
       585
       +
       permissions.  However, no additional obligations are imposed on any

     

       586
       586
       +
       author or copyright holder as a result of your choosing to follow a

     

       587
       587
       +
       later version.

     

       588
       588
       +
       

     

       589
       589
       +
         15. Disclaimer of Warranty.

     

       590
       590
       +
       

     

       591
       591
       +
         THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY

     

       592
       592
       +
       APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT

     

       593
       593
       +
       HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY

     

       594
       594
       +
       OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,

     

       595
       595
       +
       THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

     

       596
       596
       +
       PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM

     

       597
       597
       +
       IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF

     

       598
       598
       +
       ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

     

       599
       599
       +
       

     

       600
       600
       +
         16. Limitation of Liability.

     

       601
       601
       +
       

     

       602
       602
       +
         IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

     

       603
       603
       +
       WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS

     

       604
       604
       +
       THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY

     

       605
       605
       +
       GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE

     

       606
       606
       +
       USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF

     

       607
       607
       +
       DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD

     

       608
       608
       +
       PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),

     

       609
       609
       +
       EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF

     

       610
       610
       +
       SUCH DAMAGES.

     

       611
       611
       +
       

     

       612
       612
       +
         17. Interpretation of Sections 15 and 16.

     

       613
       613
       +
       

     

       614
       614
       +
         If the disclaimer of warranty and limitation of liability provided

     

       615
       615
       +
       above cannot be given local legal effect according to their terms,

     

       616
       616
       +
       reviewing courts shall apply local law that most closely approximates

     

       617
       617
       +
       an absolute waiver of all civil liability in connection with the

     

       618
       618
       +
       Program, unless a warranty or assumption of liability accompanies a

     

       619
       619
       +
       copy of the Program in return for a fee.

     

       620
       620
       +
       

     

       621
       621
       +
                            END OF TERMS AND CONDITIONS

     

       622
       622
       +
       

     

       623
       623
       +
                   How to Apply These Terms to Your New Programs

     

       624
       624
       +
       

     

       625
       625
       +
         If you develop a new program, and you want it to be of the greatest

     

       626
       626
       +
       possible use to the public, the best way to achieve this is to make it

     

       627
       627
       +
       free software which everyone can redistribute and change under these terms.

     

       628
       628
       +
       

     

       629
       629
       +
         To do so, attach the following notices to the program.  It is safest

     

       630
       630
       +
       to attach them to the start of each source file to most effectively

     

       631
       631
       +
       state the exclusion of warranty; and each file should have at least

     

       632
       632
       +
       the "copyright" line and a pointer to where the full notice is found.

     

       633
       633
       +
       

     

       634
       634
       +
           <one line to give the program's name and a brief idea of what it does.>

     

       635
       635
       +
           Copyright (C) <year>  <name of author>

     

       636
       636
       +
       

     

       637
       637
       +
           This program is free software: you can redistribute it and/or modify

     

       638
       638
       +
           it under the terms of the GNU General Public License as published by

     

       639
       639
       +
           the Free Software Foundation, either version 3 of the License, or

     

       640
       640
       +
           (at your option) any later version.

     

       641
       641
       +
       

     

       642
       642
       +
           This program is distributed in the hope that it will be useful,

     

       643
       643
       +
           but WITHOUT ANY WARRANTY; without even the implied warranty of

     

       644
       644
       +
           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     

       645
       645
       +
           GNU General Public License for more details.

     

       646
       646
       +
       

     

       647
       647
       +
           You should have received a copy of the GNU General Public License

     

       648
       648
       +
           along with this program.  If not, see <https://www.gnu.org/licenses/>.

     

       649
       649
       +
       

     

       650
       650
       +
       Also add information on how to contact you by electronic and paper mail.

     

       651
       651
       +
       

     

       652
       652
       +
         If the program does terminal interaction, make it output a short

     

       653
       653
       +
       notice like this when it starts in an interactive mode:

     

       654
       654
       +
       

     

       655
       655
       +
           <program>  Copyright (C) <year>  <name of author>

     

       656
       656
       +
           This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

     

       657
       657
       +
           This is free software, and you are welcome to redistribute it

     

       658
       658
       +
           under certain conditions; type `show c' for details.

     

       659
       659
       +
       

     

       660
       660
       +
       The hypothetical commands `show w' and `show c' should show the appropriate

     

       661
       661
       +
       parts of the General Public License.  Of course, your program's commands

     

       662
       662
       +
       might be different; for a GUI interface, you would use an "about box".

     

       663
       663
       +
       

     

       664
       664
       +
         You should also get your employer (if you work as a programmer) or school,

     

       665
       665
       +
       if any, to sign a "copyright disclaimer" for the program, if necessary.

     

       666
       666
       +
       For more information on this, and how to apply and follow the GNU GPL, see

     

       667
       667
       +
       <https://www.gnu.org/licenses/>.

     

       668
       668
       +
       

     

       669
       669
       +
         The GNU General Public License does not permit incorporating your program

     

       670
       670
       +
       into proprietary programs.  If your program is a subroutine library, you

     

       671
       671
       +
       may consider it more useful to permit linking proprietary applications with

     

       672
       672
       +
       the library.  If this is what you want to do, use the GNU Lesser General

     

       673
       673
       +
       Public License instead of this License.  But first, please read

     

       674
       674
       +
       <https://www.gnu.org/licenses/why-not-lgpl.html>.

     

       675
       675
       +

README.md

···

       1
       1
       +
       # Frostium Operating System

     

       2
       2
       +
       

     

       3
       3
       +
       This is the monorepo for the Frostium Operating System. Run

     

       4
       4
       +
       `nix develop` to get a dev env, and `zig build` to build for the

     

       5
       5
       +
       default amd64 architecture. To run the operating system in a `qemu`

     

       6
       6
       +
       emulator, run `zig build qemu`.

assets/limine.conf

···

       1
       1
       +
       /+Frostium Kernels

     

       2
       2
       +
       //AMD64 Kernel

     

       3
       3
       +
         protocol: limine

     

       4
       4
       +
         path: boot():/kernel-amd64.elf

     

       5
       5
       +
         module_path: boot():/init-amd64.elf

     

       6
       6
       +
       //aarch64 Kernel

     

       7
       7
       +
         protocol: limine

     

       8
       8
       +
         path: boot():/kernel-aarch64.elf

     

       9
       9
       +
         module_path: boot():/init-aarch64.elf

+54

build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const build_helpers = @import("build_helpers");

     

       3
       3
       +
       

     

       4
       4
       +
       pub fn build(b: *std.Build) void {

     

       5
       5
       +
           const arch = b.option(build_helpers.Architecture, "arch", "The target architecture") orelse .amd64;

     

       6
       6
       +
       

     

       7
       7
       +
           const ukernel_dep = b.dependency("ukernel", .{

     

       8
       8
       +
               .arch = arch,

     

       9
       9
       +
           });

     

       10
       10
       +
           const ukernel_artifact = ukernel_dep.artifact("ukernel");

     

       11
       11
       +
           const ukernel_inst = b.addInstallFile(ukernel_artifact.getEmittedBin(), arch.kernelExeName());

     

       12
       12
       +
           b.default_step.dependOn(&ukernel_inst.step);

     

       13
       13
       +
       

     

       14
       14
       +
           const root_dep = b.dependency("root_server", .{

     

       15
       15
       +
               .arch = arch,

     

       16
       16
       +
           });

     

       17
       17
       +
           const root_artifact = root_dep.artifact("root_server");

     

       18
       18
       +
           const root_inst = b.addInstallFile(root_artifact.getEmittedBin(), arch.rootTaskName());

     

       19
       19
       +
           b.default_step.dependOn(&root_inst.step);

     

       20
       20
       +
       

     

       21
       21
       +
           // Run in QEMU

     

       22
       22
       +
           run_blk: {

     

       23
       23
       +
               // Step 1: Install edk2 files to zig-out

     

       24
       24
       +
               const ovmf_code, const ovmf_vars = blk: {

     

       25
       25
       +
                   const ovmf_dep = b.lazyDependency("edk2_binary", .{}) orelse break :run_blk;

     

       26
       26
       +
                   break :blk .{

     

       27
       27
       +
                       ovmf_dep.path("bin/RELEASEX64_OVMF_CODE.fd"),

     

       28
       28
       +
                       ovmf_dep.path("bin/RELEASEX64_OVMF_VARS.fd"),

     

       29
       29
       +
                   };

     

       30
       30
       +
               };

     

       31
       31
       +
       

     

       32
       32
       +
               const loader_path = blk: {

     

       33
       33
       +
                   const limine_dep = b.lazyDependency("limine_binary", .{}) orelse break :run_blk;

     

       34
       34
       +
                   break :blk limine_dep.path("BOOTX64.EFI");

     

       35
       35
       +
               };

     

       36
       36
       +
       

     

       37
       37
       +
               const code_install = b.addInstallFile(ovmf_code, "OVMF_CODE_X64.fd");

     

       38
       38
       +
               const vars_install = b.addInstallFile(ovmf_vars, "OVMF_VARS_X64.fd");

     

       39
       39
       +
               const loader_install = b.addInstallFileWithDir(loader_path, .{ .custom = "EFI/BOOT" }, "BOOTX64.EFI");

     

       40
       40
       +
               const config_install = b.addInstallFileWithDir(b.path("assets/limine.conf"), .{ .custom = "limine" }, "limine.conf");

     

       41
       41
       +
       

     

       42
       42
       +
               const qemu_prepare_step = b.step("qemu_prepare", "Prepare for QEMU run");

     

       43
       43
       +
               qemu_prepare_step.dependOn(&code_install.step);

     

       44
       44
       +
               qemu_prepare_step.dependOn(&vars_install.step);

     

       45
       45
       +
               qemu_prepare_step.dependOn(&loader_install.step);

     

       46
       46
       +
               qemu_prepare_step.dependOn(&config_install.step);

     

       47
       47
       +
       

     

       48
       48
       +
               const qemu_cmd = b.addSystemCommand(&.{ "qemu-system-x86_64", "-smp", "4", "-m", "4G", "-monitor", "stdio", "-drive", "format=raw,file=fat:rw:zig-out", "-drive", "if=pflash,format=raw,readonly=on,file=zig-out/OVMF_CODE_X64.fd", "-drive", "if=pflash,format=raw,file=zig-out/OVMF_VARS_X64.fd" });

     

       49
       49
       +
               const qemu_step = b.step("qemu", "Run in QEMU");

     

       50
       50
       +
               qemu_step.dependOn(b.default_step);

     

       51
       51
       +
               qemu_step.dependOn(qemu_prepare_step);

     

       52
       52
       +
               qemu_step.dependOn(&qemu_cmd.step);

     

       53
       53
       +
           }

     

       54
       54
       +
       }

+37

build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .frostium,

     

       3
       3
       +
           .version = "0.0.1",

     

       4
       4
       +
           .fingerprint = 0x8d91c7f5c1556c13,

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{

     

       7
       7
       +
               .ukernel = .{

     

       8
       8
       +
                   .path = "components/ukernel",

     

       9
       9
       +
               },

     

       10
       10
       +
               .root_server = .{

     

       11
       11
       +
                   .path = "components/root_server",

     

       12
       12
       +
               },

     

       13
       13
       +
               .build_helpers = .{

     

       14
       14
       +
                   .path = "components/build_helpers",

     

       15
       15
       +
               },

     

       16
       16
       +
               .limine_binary = .{

     

       17
       17
       +
                   .url = "git+https://codeberg.org/Limine/Limine?ref=v9.x-binary#acf1e35c4685dba7ef271013db375a727c340ff7",

     

       18
       18
       +
                   .hash = "N-V-__8AAOkzSACT_9p6kmSSly1l008erzXuG39Z6r54B_y0",

     

       19
       19
       +
                   // Codeberg is always down so better to leave it not lazy

     

       20
       20
       +
                   // .lazy = true,

     

       21
       21
       +
               },

     

       22
       22
       +
               .edk2_binary = .{

     

       23
       23
       +
                   .url = "git+https://github.com/retrage/edk2-nightly#23068f498687bf64f2b8f80fbcf11e82d987fd9b",

     

       24
       24
       +
                   .hash = "N-V-__8AADFwUgat_qAH_zWVQeUqhpPP05V2Gr_XYRAqhIkb",

     

       25
       25
       +
                   .lazy = true,

     

       26
       26
       +
               },

     

       27
       27
       +
           },

     

       28
       28
       +
           .paths = .{

     

       29
       29
       +
               "build.zig",

     

       30
       30
       +
               "build.zig.zon",

     

       31
       31
       +
               "flake.nix",

     

       32
       32
       +
               "flake.lock",

     

       33
       33
       +
               "LICENSE",

     

       34
       34
       +
               "README.md",

     

       35
       35
       +
               "ukernel",

     

       36
       36
       +
           },

     

       37
       37
       +
       }

components/build_helpers/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const build_helpers = @import("root.zig");

     

       3
       3
       +
       pub const Architecture = build_helpers.Architecture;

     

       4
       4
       +
       

     

       5
       5
       +
       pub fn build(b: *std.Build) void {

     

       6
       6
       +
           _ = b.addModule("build_helpers", .{

     

       7
       7
       +
               .root_source_file = b.path("root.zig"),

     

       8
       8
       +
           });

     

       9
       9
       +
       }

+32

components/build_helpers/root.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub const Architecture = enum {

     

       4
       4
       +
           const Self = @This();

     

       5
       5
       +
           aarch64,

     

       6
       6
       +
           riscv64,

     

       7
       7
       +
           amd64,

     

       8
       8
       +
       

     

       9
       9
       +
           pub fn get(self: *const Self) std.Target.Cpu.Arch {

     

       10
       10
       +
               return switch (self.*) {

     

       11
       11
       +
                   .aarch64 => .aarch64,

     

       12
       12
       +
                   .riscv64 => .riscv64,

     

       13
       13
       +
                   .amd64 => .x86_64,

     

       14
       14
       +
               };

     

       15
       15
       +
           }

     

       16
       16
       +
       

     

       17
       17
       +
           pub fn kernelExeName(self: *const Self) []const u8 {

     

       18
       18
       +
               return switch (self.*) {

     

       19
       19
       +
                   .aarch64 => "kernel-aarch64.elf",

     

       20
       20
       +
                   .riscv64 => "kernel-riscv64.elf",

     

       21
       21
       +
                   .amd64 => "kernel-amd64.elf",

     

       22
       22
       +
               };

     

       23
       23
       +
           }

     

       24
       24
       +
       

     

       25
       25
       +
           pub fn rootTaskName(self: *const Self) []const u8 {

     

       26
       26
       +
               return switch (self.*) {

     

       27
       27
       +
                   .aarch64 => "init-aarch64.elf",

     

       28
       28
       +
                   .riscv64 => "init-riscv64.elf",

     

       29
       29
       +
                   .amd64 => "init-amd64.elf",

     

       30
       30
       +
               };

     

       31
       31
       +
           }

     

       32
       32
       +
       };

+35

components/root_server/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const build_helpers = @import("build_helpers");

     

       3
       3
       +
       

     

       4
       4
       +
       pub fn build(b: *std.Build) void {

     

       5
       5
       +
           const arch = b.option(build_helpers.Architecture, "arch", "The target root_server architecture") orelse .amd64;

     

       6
       6
       +
       

     

       7
       7
       +
           // set CPU features based on the architecture

     

       8
       8
       +
           const target = b.resolveTargetQuery(.{

     

       9
       9
       +
               .cpu_arch = arch.get(),

     

       10
       10
       +
               .os_tag = .freestanding,

     

       11
       11
       +
               .abi = .none,

     

       12
       12
       +
           });

     

       13
       13
       +
           const optimize = b.standardOptimizeOption(.{});

     

       14
       14
       +
       

     

       15
       15
       +
           const main_mod = b.createModule(.{

     

       16
       16
       +
               .root_source_file = b.path("src/main.zig"),

     

       17
       17
       +
               .target = target,

     

       18
       18
       +
               .optimize = optimize,

     

       19
       19
       +
           });

     

       20
       20
       +
       

     

       21
       21
       +
           const config = b.addOptions();

     

       22
       22
       +
           config.addOption(build_helpers.Architecture, "arch", arch);

     

       23
       23
       +
       

     

       24
       24
       +
           const build_helpers_dep = b.dependency("build_helpers", .{});

     

       25
       25
       +
       

     

       26
       26
       +
           main_mod.addImport("config", config.createModule());

     

       27
       27
       +
           main_mod.addImport("build_helpers", build_helpers_dep.module("build_helpers"));

     

       28
       28
       +
       

     

       29
       29
       +
           const exe = b.addExecutable(.{

     

       30
       30
       +
               .name = "root_server",

     

       31
       31
       +
               .root_module = main_mod,

     

       32
       32
       +
           });

     

       33
       33
       +
       

     

       34
       34
       +
           b.installArtifact(exe);

     

       35
       35
       +
       }

+14

components/root_server/build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .root_server,

     

       3
       3
       +
           .version = "0.0.0",

     

       4
       4
       +
           .fingerprint = 0x78d73937eee4ef25,

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{

     

       7
       7
       +
               .build_helpers = .{ .path = "../build_helpers" },

     

       8
       8
       +
           },

     

       9
       9
       +
           .paths = .{

     

       10
       10
       +
               "build.zig",

     

       11
       11
       +
               "build.zig.zon",

     

       12
       12
       +
               "src",

     

       13
       13
       +
           },

     

       14
       14
       +
       }

+10

components/root_server/src/main.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const os = @import("os.zig");

     

       3
       3
       +
       

     

       4
       4
       +
       export fn _start() callconv(.c) noreturn {

     

       5
       5
       +
           _ = os.syscall1(SYS_poke, 0xB16B00B5BADBABE);

     

       6
       6
       +
           _ = os.syscall1(SYS_exit, 0);

     

       7
       7
       +
           unreachable;

     

       8
       8
       +
       }

     

       9
       9
       +
       pub const SYS_exit = 69;

     

       10
       10
       +
       pub const SYS_poke = 420;

+38

components/root_server/src/os.zig

···

       1
       1
       +
       const config = @import("config");

     

       2
       2
       +
       const build_helpers = @import("build_helpers");

     

       3
       3
       +
       

     

       4
       4
       +
       pub const syscall1 = switch (config.arch) {

     

       5
       5
       +
           .aarch64 => Aarch64.syscall1,

     

       6
       6
       +
           .amd64 => Amd64.syscall1,

     

       7
       7
       +
           .riscv64 => Riscv64.syscall1,

     

       8
       8
       +
       };

     

       9
       9
       +
       

     

       10
       10
       +
       const Aarch64 = struct {

     

       11
       11
       +
           pub fn syscall1(number: usize, arg1: usize) usize {

     

       12
       12
       +
               return asm volatile ("svc #0"

     

       13
       13
       +
                   : [ret] "={x0}" (-> usize),

     

       14
       14
       +
                   : [number] "{x8}" (number),

     

       15
       15
       +
                     [arg1] "{x0}" (arg1),

     

       16
       16
       +
                   : .{ .memory = true });

     

       17
       17
       +
           }

     

       18
       18
       +
       };

     

       19
       19
       +
       

     

       20
       20
       +
       const Amd64 = struct {

     

       21
       21
       +
           pub fn syscall1(number: usize, arg1: usize) usize {

     

       22
       22
       +
               return asm volatile ("syscall"

     

       23
       23
       +
                   : [ret] "={rax}" (-> usize),

     

       24
       24
       +
                   : [number] "{rax}" (number),

     

       25
       25
       +
                     [arg1] "{rdi}" (arg1),

     

       26
       26
       +
                   : .{ .rcx = true, .r11 = true });

     

       27
       27
       +
           }

     

       28
       28
       +
       };

     

       29
       29
       +
       

     

       30
       30
       +
       const Riscv64 = struct {

     

       31
       31
       +
           pub fn syscall1(number: usize, arg1: usize) usize {

     

       32
       32
       +
               return asm volatile ("ecall"

     

       33
       33
       +
                   : [ret] "={x10}" (-> usize),

     

       34
       34
       +
                   : [number] "{x17}" (number),

     

       35
       35
       +
                     [arg1] "{x10}" (arg1),

     

       36
       36
       +
                   : .{ .memory = true });

     

       37
       37
       +
           }

     

       38
       38
       +
       };

+101

components/ukernel/arch/aarch64/boot.zig

···

       1
       1
       +
       const limine = @import("limine");

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const arch = @import("root.zig");

     

       4
       4
       +
       const common = @import("common");

     

       5
       5
       +
       const console = @import("console");

     

       6
       6
       +
       const log = std.log.scoped(.aarch64_init);

     

       7
       7
       +
       

     

       8
       8
       +
       pub const limine_requests = struct {

     

       9
       9
       +
           // export var start_marker: limine.RequestsStartMarker linksection(".limine_reqs_start") = .{};

     

       10
       10
       +
           // export var end_marker: limine.RequestsEndMarker linksection(".limine_reqs_end") = .{};

     

       11
       11
       +
       

     

       12
       12
       +
           pub export var base_revision: limine.BaseRevision = .{ .revision = 3 };

     

       13
       13
       +
           pub export var framebuffer: limine.FramebufferRequest = .{};

     

       14
       14
       +
           pub export var hhdm: limine.HhdmRequest = .{};

     

       15
       15
       +
           pub export var memmap: limine.MemoryMapRequest = .{};

     

       16
       16
       +
           pub export var rsdp_req: limine.RsdpRequest = .{};

     

       17
       17
       +
           pub export var dtb_req: limine.DtbRequest = .{};

     

       18
       18
       +
           pub export var modules: limine.ModuleRequest = .{};

     

       19
       19
       +
           pub export var mp: limine.SmpMpFeature.MpRequest = .{};

     

       20
       20
       +
       };

     

       21
       21
       +
       

     

       22
       22
       +
       pub fn bsp_init() callconv(.c) noreturn {

     

       23
       23
       +
           if (limine_requests.framebuffer.response) |fb_response| {

     

       24
       24
       +
               if (fb_response.framebuffer_count > 0) {

     

       25
       25
       +
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       26
       26
       +
                   common.init_data.framebuffer = fb;

     

       27
       27
       +
                   @memset(fb.address[0..64], 0xFF);

     

       28
       28
       +
               }

     

       29
       29
       +
           }

     

       30
       30
       +
           arch.instructions.die();

     

       31
       31
       +
           // Don't optimize away the limine requests

     

       32
       32
       +
           inline for (@typeInfo(limine_requests).@"struct".decls) |decl| {

     

       33
       33
       +
               std.mem.doNotOptimizeAway(&@field(limine_requests, decl.name));

     

       34
       34
       +
           }

     

       35
       35
       +
       

     

       36
       36
       +
           // If the base revision isn't supported, we can't boot

     

       37
       37
       +
           if (!limine_requests.base_revision.isSupported()) {

     

       38
       38
       +
               @branchHint(.cold);

     

       39
       39
       +
               arch.instructions.die();

     

       40
       40
       +
           }

     

       41
       41
       +
       

     

       42
       42
       +
           // Die if we don't have a memory map or Higher Half Direct Mapping

     

       43
       43
       +
           if (limine_requests.memmap.response == null) {

     

       44
       44
       +
               @branchHint(.cold);

     

       45
       45
       +
               arch.instructions.die();

     

       46
       46
       +
           }

     

       47
       47
       +
       

     

       48
       48
       +
           if (limine_requests.hhdm.response == null) {

     

       49
       49
       +
               @branchHint(.cold);

     

       50
       50
       +
               arch.instructions.die();

     

       51
       51
       +
           }

     

       52
       52
       +
           const hhdm_offset = limine_requests.hhdm.response.?.offset;

     

       53
       53
       +
           common.init_data.hhdm_slide = hhdm_offset;

     

       54
       54
       +
       

     

       55
       55
       +
           // Add in a framebuffer if found

     

       56
       56
       +
           initConsole();

     

       57
       57
       +
       

     

       58
       58
       +
           // Add in ACPI/dtb if found

     

       59
       59
       +
           initHwDesc();

     

       60
       60
       +
       

     

       61
       61
       +
           // Set up the temporary Physical Memory Allocator

     

       62
       62
       +
           common.mm.bootmem.init();

     

       63
       63
       +
       

     

       64
       64
       +
           // Attach the root task

     

       65
       65
       +
           if (limine_requests.modules.response) |module_response| {

     

       66
       66
       +
               if (module_response.module_count > 0) {

     

       67
       67
       +
                   const mod = module_response.modules.?[0];

     

       68
       68
       +
                   const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       69
       69
       +
                   const mod_size = mod.size;

     

       70
       70
       +
                   log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       71
       71
       +
                   common.init_data.root_task = mod_addr[0..mod_size];

     

       72
       72
       +
               }

     

       73
       73
       +
           } else {

     

       74
       74
       +
               @branchHint(.unlikely);

     

       75
       75
       +
               @panic("No root task found!");

     

       76
       76
       +
           }

     

       77
       77
       +
       

     

       78
       78
       +
           log.info("Nothing else to do!", .{});

     

       79
       79
       +
       

     

       80
       80
       +
           arch.instructions.die();

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       fn initConsole() void {

     

       84
       84
       +
           if (limine_requests.framebuffer.response) |fb_response| {

     

       85
       85
       +
               if (fb_response.framebuffer_count > 0) {

     

       86
       86
       +
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       87
       87
       +
                   common.init_data.framebuffer = fb;

     

       88
       88
       +
                   // At this point, log becomes usable

     

       89
       89
       +
                   common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

     

       90
       90
       +
               }

     

       91
       91
       +
           }

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       fn initHwDesc() void {

     

       95
       95
       +
           if (limine_requests.dtb_req.response) |dtb_response| {

     

       96
       96
       +
               common.init_data.hardware_description = .{ .dtb = dtb_response.dtb_ptr };

     

       97
       97
       +
           }

     

       98
       98
       +
           if (limine_requests.rsdp_req.response) |rsdp_response| {

     

       99
       99
       +
               common.init_data.hardware_description = .{ .acpi_rsdp = rsdp_response.address };

     

       100
       100
       +
           }

     

       101
       101
       +
       }

components/ukernel/arch/aarch64/instructions.zig

···

       1
       1
       +
       pub inline fn die() noreturn {

     

       2
       2
       +
           while (true) {

     

       3
       3
       +
               asm volatile ("wfi");

     

       4
       4
       +
           }

     

       5
       5
       +
       }

+45

components/ukernel/arch/aarch64/linker.ld

···

       1
       1
       +
       OUTPUT_FORMAT(elf64-littleaarch64)

     

       2
       2
       +
       ENTRY(_start)

     

       3
       3
       +
       

     

       4
       4
       +
       PHDRS {

     

       5
       5
       +
           limine_reqs PT_LOAD;

     

       6
       6
       +
           text    PT_LOAD;

     

       7
       7
       +
           rodata  PT_LOAD;

     

       8
       8
       +
           data    PT_LOAD;

     

       9
       9
       +
           dynamic PT_DYNAMIC;

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       SECTIONS {

     

       13
       13
       +
           . = 0xffffffff80000000;

     

       14
       14
       +
       

     

       15
       15
       +
           .text : {

     

       16
       16
       +
               *(.text .text.*)

     

       17
       17
       +
           } :text

     

       18
       18
       +
       

     

       19
       19
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       20
       20
       +
       

     

       21
       21
       +
           .rodata : {

     

       22
       22
       +
               *(.rodata .rodata.*)

     

       23
       23
       +
           } :rodata

     

       24
       24
       +
       

     

       25
       25
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       26
       26
       +
       

     

       27
       27
       +
           .data : {

     

       28
       28
       +
               *(.data .data.*)

     

       29
       29
       +
       

     

       30
       30
       +
           } :data

     

       31
       31
       +
       

     

       32
       32
       +
           .dynamic : {

     

       33
       33
       +
             *(.dynamic)

     

       34
       34
       +
           } :data :dynamic

     

       35
       35
       +
       

     

       36
       36
       +
           .bss : {

     

       37
       37
       +
               *(.bss .bss.*)

     

       38
       38
       +
               *(COMMON)

     

       39
       39
       +
           } :data

     

       40
       40
       +
       

     

       41
       41
       +
           /DISCARD/ : {

     

       42
       42
       +
               *(.eh_frame*)

     

       43
       43
       +
               *(.note .note.*)

     

       44
       44
       +
           }

     

       45
       45
       +
       }

+27

components/ukernel/arch/aarch64/root.zig

···

       1
       1
       +
       pub const boot = @import("boot.zig");

     

       2
       2
       +
       pub const instructions = @import("instructions.zig");

     

       3
       3
       +
       // pub const structures = @import("structures/root.zig");

     

       4
       4
       +
       // pub const registers = @import("registers.zig");

     

       5
       5
       +
       const common = @import("common");

     

       6
       6
       +
       const std = @import("std");

     

       7
       7
       +
       

     

       8
       8
       +
       // Early BSP init may override this if a more optimal

     

       9
       9
       +
       // page size is chosen.

     

       10
       10
       +
       var negotiated_page_size: u32 = 4096;

     

       11
       11
       +
       

     

       12
       12
       +
       fn pageSize() usize {

     

       13
       13
       +
           return @intCast(negotiated_page_size);

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       pub const std_options: std.Options = .{

     

       17
       17
       +
           .logFn = common.aux.logFn,

     

       18
       18
       +
           .page_size_min = 4 << 10,

     

       19
       19
       +
           .page_size_max = 64 << 10,

     

       20
       20
       +
           .queryPageSize = pageSize,

     

       21
       21
       +
       };

     

       22
       22
       +
       pub const panic = std.debug.FullPanic(common.aux.panic);

     

       23
       23
       +
       

     

       24
       24
       +
       comptime {

     

       25
       25
       +
           // Entry point (_start)

     

       26
       26
       +
           @export(&boot.bsp_init, .{ .name = "_start", .linkage = .strong });

     

       27
       27
       +
       }

+42

components/ukernel/arch/amd64/asm/traps.S

···

       1
       1
       +
       .section .text

     

       2
       2
       +
       

     

       3
       3
       +
       .globl syscall_entry

     

       4
       4
       +
       .type syscall_entry, %function

     

       5
       5
       +
       syscall_entry:

     

       6
       6
       +
       

     

       7
       7
       +
           # swapgs in the future

     

       8
       8
       +
           push    %rcx

     

       9
       9
       +
           push    %r11

     

       10
       10
       +
           push    %r15

     

       11
       11
       +
           push    %r9

     

       12
       12
       +
           push    %r8

     

       13
       13
       +
           push    %r10

     

       14
       14
       +
           push    %rdx

     

       15
       15
       +
           push    %r14

     

       16
       16
       +
           push    %r13

     

       17
       17
       +
           push    %r12

     

       18
       18
       +
           push    %rbp

     

       19
       19
       +
           push    %rbx

     

       20
       20
       +
           push    %rax

     

       21
       21
       +
           push    %rsi

     

       22
       22
       +
           push    %rdi

     

       23
       23
       +
       

     

       24
       24
       +
           call syscall_handler

     

       25
       25
       +
       

     

       26
       26
       +
           pop    %rdi

     

       27
       27
       +
           pop    %rsi

     

       28
       28
       +
           pop    %rax

     

       29
       29
       +
           pop    %rbx

     

       30
       30
       +
           pop    %rbp

     

       31
       31
       +
           pop    %r12

     

       32
       32
       +
           pop    %r13

     

       33
       33
       +
           pop    %r14

     

       34
       34
       +
           pop    %rdx

     

       35
       35
       +
           pop    %r10

     

       36
       36
       +
           pop    %r8

     

       37
       37
       +
           pop    %r9

     

       38
       38
       +
           pop    %r15

     

       39
       39
       +
           pop    %r11

     

       40
       40
       +
           pop    %rcx

     

       41
       41
       +
       

     

       42
       42
       +
           sysretq

+364

components/ukernel/arch/amd64/boot.zig

···

       1
       1
       +
       const limine = @import("limine");

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const arch = @import("root.zig");

     

       4
       4
       +
       const common = @import("common");

     

       5
       5
       +
       const console = @import("console");

     

       6
       6
       +
       const log = std.log.scoped(.amd64_init);

     

       7
       7
       +
       const Idt = arch.structures.Idt;

     

       8
       8
       +
       const StandardGdt = arch.structures.gdt.StandardGdt;

     

       9
       9
       +
       const Tss = arch.structures.tss.Tss;

     

       10
       10
       +
       

     

       11
       11
       +
       var per_cpu_init_data: PerCpuInitData = .{};

     

       12
       12
       +
       

     

       13
       13
       +
       pub const limine_requests = struct {

     

       14
       14
       +
           export var start_marker: limine.RequestsStartMarker linksection(".limine_reqs_start") = .{};

     

       15
       15
       +
           export var end_marker: limine.RequestsEndMarker linksection(".limine_reqs_end") = .{};

     

       16
       16
       +
       

     

       17
       17
       +
           pub export var base_revision: limine.BaseRevision linksection(".limine_reqs") = .{ .revision = 3 };

     

       18
       18
       +
           pub export var framebuffer: limine.FramebufferRequest linksection(".limine_reqs") = .{};

     

       19
       19
       +
           pub export var hhdm: limine.HhdmRequest linksection(".limine_reqs") = .{};

     

       20
       20
       +
           pub export var memmap: limine.MemoryMapRequest linksection(".limine_reqs") = .{};

     

       21
       21
       +
           pub export var rsdp_req: limine.RsdpRequest linksection(".limine_reqs") = .{};

     

       22
       22
       +
           pub export var dtb_req: limine.DtbRequest linksection(".limine_reqs") = .{};

     

       23
       23
       +
           pub export var modules: limine.ModuleRequest linksection(".limine_reqs") = .{};

     

       24
       24
       +
           pub export var mp: limine.SmpMpFeature.MpRequest linksection(".limine_reqs") = .{ .flags = .{ .x2apic = true } };

     

       25
       25
       +
       };

     

       26
       26
       +
       

     

       27
       27
       +
       pub fn bsp_init() callconv(.c) noreturn {

     

       28
       28
       +
           // Don't optimize away the limine requests

     

       29
       29
       +
           inline for (@typeInfo(limine_requests).@"struct".decls) |decl| {

     

       30
       30
       +
               std.mem.doNotOptimizeAway(&@field(limine_requests, decl.name));

     

       31
       31
       +
           }

     

       32
       32
       +
       

     

       33
       33
       +
           // If the base revision isn't supported, we can't boot

     

       34
       34
       +
           if (!limine_requests.base_revision.isSupported()) {

     

       35
       35
       +
               @branchHint(.cold);

     

       36
       36
       +
               arch.instructions.die();

     

       37
       37
       +
           }

     

       38
       38
       +
       

     

       39
       39
       +
           // Die if we don't have a memory map or Higher Half Direct Mapping

     

       40
       40
       +
           if (limine_requests.memmap.response == null) {

     

       41
       41
       +
               @branchHint(.cold);

     

       42
       42
       +
               arch.instructions.die();

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
           if (limine_requests.hhdm.response == null) {

     

       46
       46
       +
               @branchHint(.cold);

     

       47
       47
       +
               arch.instructions.die();

     

       48
       48
       +
           }

     

       49
       49
       +
           const hhdm_offset = limine_requests.hhdm.response.?.offset;

     

       50
       50
       +
           common.init_data.hhdm_slide = hhdm_offset;

     

       51
       51
       +
       

     

       52
       52
       +
           // Add in a framebuffer if found

     

       53
       53
       +
           initConsole();

     

       54
       54
       +
       

     

       55
       55
       +
           // Add in ACPI/dtb if found, prefer ACPI

     

       56
       56
       +
           initHwDesc();

     

       57
       57
       +
       

     

       58
       58
       +
           // Set up the temporary Physical Memory Allocator

     

       59
       59
       +
           common.mm.bootmem.init();

     

       60
       60
       +
       

     

       61
       61
       +
           // Attach the root task

     

       62
       62
       +
           if (limine_requests.modules.response) |module_response| {

     

       63
       63
       +
               if (module_response.module_count > 0) {

     

       64
       64
       +
                   const mod = module_response.modules.?[0];

     

       65
       65
       +
                   const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       66
       66
       +
                   const mod_size = mod.size;

     

       67
       67
       +
                   log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       68
       68
       +
                   common.init_data.root_task = mod_addr[0..mod_size];

     

       69
       69
       +
               }

     

       70
       70
       +
           } else {

     

       71
       71
       +
               @branchHint(.unlikely);

     

       72
       72
       +
               @panic("No root task found!");

     

       73
       73
       +
           }

     

       74
       74
       +
       

     

       75
       75
       +
           // Initialize per-cpu data (GDT and TSS)

     

       76
       76
       +
           per_cpu_init_data.init();

     

       77
       77
       +
       

     

       78
       78
       +
           // Install the IDT

     

       79
       79
       +
           initIdt();

     

       80
       80
       +
       

     

       81
       81
       +
           // AP bootstrap

     

       82
       82
       +
           bootstrapAPs();

     

       83
       83
       +
       

     

       84
       84
       +
           // Set up our own GDT and TSS

     

       85
       85
       +
           const gdt = &per_cpu_init_data.gdt_buf[0];

     

       86
       86
       +
           gdt.* = .{};

     

       87
       87
       +
           const tss = &per_cpu_init_data.tss_buf[0];

     

       88
       88
       +
           // TSS rsp 0x3800

     

       89
       89
       +
           tss.* = .{

     

       90
       90
       +
               .rsp0 = 0x3800,

     

       91
       91
       +
               .rsp1 = 0x3800,

     

       92
       92
       +
               .rsp2 = 0x3800,

     

       93
       93
       +
           };

     

       94
       94
       +
       

     

       95
       95
       +
           gdt.tss_desc.set_tss_addr(tss);

     

       96
       96
       +
           gdt.load();

     

       97
       97
       +
           log.info("BSP successfully setup GDT+TSS!", .{});

     

       98
       98
       +
       

     

       99
       99
       +
           log.info("Allocating code for userspace...", .{});

     

       100
       100
       +
       

     

       101
       101
       +
           const user_code = common.init_data.bootmem.allocPhys(0x1000) catch @panic("alloc bruh");

     

       102
       102
       +
           const user_stack = common.init_data.bootmem.allocPhys(0x1000) catch @panic("alloc bruh2");

     

       103
       103
       +
       

     

       104
       104
       +
           // TODO: load the actual root task ELF for fucks sake

     

       105
       105
       +
           // instead of the current glorified shellcode

     

       106
       106
       +
       

     

       107
       107
       +
           // Map our executable page to 0x1000

     

       108
       108
       +
           common.mm.paging.mapPhys(.{

     

       109
       109
       +
               .vaddr = 0x8000,

     

       110
       110
       +
               .paddr = user_code,

     

       111
       111
       +
               .size = 0x1000,

     

       112
       112
       +
               .memory_type = .MemoryWriteBack,

     

       113
       113
       +
               .perms = .{

     

       114
       114
       +
                   .executable = true,

     

       115
       115
       +
                   .writable = false,

     

       116
       116
       +
                   .userspace_accessible = true,

     

       117
       117
       +
               },

     

       118
       118
       +
           }) catch {

     

       119
       119
       +
               @panic("Mapping failed!!!!!");

     

       120
       120
       +
           };

     

       121
       121
       +
       

     

       122
       122
       +
           // Map our stack page to 0x3000 (starts at 0x4000)

     

       123
       123
       +
           common.mm.paging.mapPhys(.{

     

       124
       124
       +
               .vaddr = 0x3000,

     

       125
       125
       +
               .paddr = user_stack,

     

       126
       126
       +
               .size = 0x1000,

     

       127
       127
       +
               .memory_type = .MemoryWriteBack,

     

       128
       128
       +
               .perms = .{

     

       129
       129
       +
                   .executable = false,

     

       130
       130
       +
                   .writable = true,

     

       131
       131
       +
                   .userspace_accessible = true,

     

       132
       132
       +
               },

     

       133
       133
       +
           }) catch {

     

       134
       134
       +
               @panic("Mapping failed!!!!!");

     

       135
       135
       +
           };

     

       136
       136
       +
       

     

       137
       137
       +
           // Place shellcode there (does a couple syscalls then jmp $ infinite loop)

     

       138
       138
       +
           const memory: [*]u8 = common.mm.physToHHDM([*]u8, user_code);

     

       139
       139
       +
           const shellcode = [_]u8{ 0x48, 0xBF, 0xE1, 0xAB, 0xDB, 0xBA, 0xB5, 0x00, 0x6B, 0xB1, 0x48, 0xBE, 0x06, 0x42, 0x69, 0x20, 0x94, 0x06, 0x42, 0x69, 0x0F, 0x05, 0xBF, 0x11, 0xCA, 0x00, 0x00, 0xBE, 0x69, 0x69, 0x69, 0x69, 0x0F, 0x05, 0xEB, 0xFE };

     

       140
       140
       +
           @memcpy(memory[0..@sizeOf(@TypeOf(shellcode))], shellcode[0..]);

     

       141
       141
       +
       

     

       142
       142
       +
           // Set up MSRs to enable syscalls

     

       143
       143
       +
           init_syscalls();

     

       144
       144
       +
       

     

       145
       145
       +
           // Finally, iretq ourselves into this bitch

     

       146
       146
       +
           enter_userspace(0x8000, 0x69, 0x3800);

     

       147
       147
       +
       }

     

       148
       148
       +
       

     

       149
       149
       +
       // Get ready for system calls (set MSRs)

     

       150
       150
       +
       fn init_syscalls() void {

     

       151
       151
       +
           // Set up the STAR MSR with the segment descriptors

     

       152
       152
       +
           const IA32_STAR = arch.registers.MSR(u64, 0xC0000081);

     

       153
       153
       +
           const star_value: u64 = 0 | @as(u64, arch.structures.gdt.StandardGdt.selectors.kernel_code) << 32 | (@as(u64, arch.structures.gdt.StandardGdt.selectors.tss_desc + 8) | 3) << 48;

     

       154
       154
       +
           IA32_STAR.write(star_value);

     

       155
       155
       +
           log.debug("Wrote 0x{x:0>16} to IA32_STAR", .{star_value});

     

       156
       156
       +
       

     

       157
       157
       +
           // Set up the EFER MSR with SCE (System Call Enable)

     

       158
       158
       +
           const IA32_EFER = arch.registers.MSR(u64, 0xC0000080);

     

       159
       159
       +
           const efer_val = IA32_EFER.read() | 0b1;

     

       160
       160
       +
           IA32_EFER.write(efer_val);

     

       161
       161
       +
           log.debug("Wrote 0x{x:0>16} to IA32_EFER", .{efer_val});

     

       162
       162
       +
       

     

       163
       163
       +
           // Set up LSTAR with the syscall handler and FMASK to clear interrupts

     

       164
       164
       +
           const IA32_LSTAR = arch.registers.MSR(u64, 0xC0000082);

     

       165
       165
       +
           IA32_LSTAR.write(@intFromPtr(syscall_entry));

     

       166
       166
       +
       

     

       167
       167
       +
           log.debug("Wrote 0x{x:0>16} to IA32_LSTAR", .{@intFromPtr(syscall_entry)});

     

       168
       168
       +
       

     

       169
       169
       +
           const IA32_FMASK = arch.registers.MSR(u64, 0xC0000084);

     

       170
       170
       +
           IA32_FMASK.write(1 << 9);

     

       171
       171
       +
           log.debug("Wrote 0x{x:0>16} to IA32_FMASK", .{1 << 9});

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       174
       174
       +
       const syscall_entry = @extern(*anyopaque, .{

     

       175
       175
       +
           .name = "syscall_entry",

     

       176
       176
       +
       });

     

       177
       177
       +
       export fn syscall_handler(rdi: usize, rsi: usize) callconv(.c) void {

     

       178
       178
       +
           std.log.info("Got a syscall! rdi=0x{x}, rsi=0x{x}", .{ rdi, rsi });

     

       179
       179
       +
       }

     

       180
       180
       +
       

     

       181
       181
       +
       fn enter_userspace(entry: u64, arg: u64, stack: u64) noreturn {

     

       182
       182
       +
           log.info("usercode64 GDT 0x{x}, userdata64 GDT 0x{x}", .{ arch.structures.gdt.StandardGdt.selectors.user_code, arch.structures.gdt.StandardGdt.selectors.user_data });

     

       183
       183
       +
           const cr3 = arch.registers.ControlRegisters.Cr3.read();

     

       184
       184
       +
           arch.registers.ControlRegisters.Cr3.write(cr3);

     

       185
       185
       +
           asm volatile (

     

       186
       186
       +
               \\ push %[userdata64]

     

       187
       187
       +
               \\ push %[stack]

     

       188
       188
       +
               \\ push $0x2

     

       189
       189
       +
               \\ push %[usercode64]

     

       190
       190
       +
               \\ push %[entry]

     

       191
       191
       +
               \\

     

       192
       192
       +
               \\ mov %[userdata64], %%rax

     

       193
       193
       +
               \\ mov %%rax, %%es

     

       194
       194
       +
               \\ mov %%rax, %%ds

     

       195
       195
       +
               \\

     

       196
       196
       +
               \\ xor %%rsi, %%rsi

     

       197
       197
       +
               \\ xor %%rax, %%rax

     

       198
       198
       +
               \\ xor %%rdx, %%rdx

     

       199
       199
       +
               \\ xor %%rcx, %%rcx

     

       200
       200
       +
               \\ xor %%rbp, %%rbp

     

       201
       201
       +
               \\ xor %%rbx, %%rbx

     

       202
       202
       +
               \\

     

       203
       203
       +
               \\ xor %%r8, %%r8

     

       204
       204
       +
               \\ xor %%r9, %%r9

     

       205
       205
       +
               \\ xor %%r10, %%r10

     

       206
       206
       +
               \\ xor %%r11, %%r11

     

       207
       207
       +
               \\ xor %%r12, %%r12

     

       208
       208
       +
               \\ xor %%r13, %%r13

     

       209
       209
       +
               \\ xor %%r14, %%r14

     

       210
       210
       +
               \\ xor %%r15, %%r15

     

       211
       211
       +
               \\

     

       212
       212
       +
               \\ iretq

     

       213
       213
       +
               \\

     

       214
       214
       +
               :

     

       215
       215
       +
               : [arg] "{rdi}" (arg),

     

       216
       216
       +
                 [stack] "r" (stack),

     

       217
       217
       +
                 [entry] "r" (entry),

     

       218
       218
       +
                 [userdata64] "i" (arch.structures.gdt.StandardGdt.selectors.user_data),

     

       219
       219
       +
                 [usercode64] "i" (arch.structures.gdt.StandardGdt.selectors.user_code),

     

       220
       220
       +
           );

     

       221
       221
       +
           unreachable;

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       224
       224
       +
       fn initConsole() void {

     

       225
       225
       +
           if (limine_requests.framebuffer.response) |fb_response| {

     

       226
       226
       +
               if (fb_response.framebuffer_count > 0) {

     

       227
       227
       +
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       228
       228
       +
                   common.init_data.framebuffer = fb;

     

       229
       229
       +
                   // At this point, log becomes usable

     

       230
       230
       +
                   common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

     

       231
       231
       +
                   common.init_data.console.?.setColor(0x3bcf1d, 0);

     

       232
       232
       +
               }

     

       233
       233
       +
           }

     

       234
       234
       +
       }

     

       235
       235
       +
       

     

       236
       236
       +
       fn initHwDesc() void {

     

       237
       237
       +
           if (limine_requests.dtb_req.response) |dtb_response| {

     

       238
       238
       +
               common.init_data.hardware_description = .{ .dtb = dtb_response.dtb_ptr };

     

       239
       239
       +
           }

     

       240
       240
       +
           if (limine_requests.rsdp_req.response) |rsdp_response| {

     

       241
       241
       +
               common.init_data.hardware_description = .{ .acpi_rsdp = rsdp_response.address };

     

       242
       242
       +
           }

     

       243
       243
       +
       }

     

       244
       244
       +
       

     

       245
       245
       +
       pub fn initIdt() void {

     

       246
       246
       +
           const idt_addr: usize = @intFromPtr(per_cpu_init_data.idt);

     

       247
       247
       +
       

     

       248
       248
       +
           // Install the known exception handlers

     

       249
       249
       +
           per_cpu_init_data.idt.breakpoint.installHandler(breakpoint_handler);

     

       250
       250
       +
           per_cpu_init_data.idt.double_fault.installHandler(double_fault);

     

       251
       251
       +
           per_cpu_init_data.idt.general_protection_fault.installHandler(gpf);

     

       252
       252
       +
           per_cpu_init_data.idt.page_fault.installHandler(page_fault);

     

       253
       253
       +
       

     

       254
       254
       +
           // Load the Idt Register

     

       255
       255
       +
           const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       256
       256
       +
           reg.load();

     

       257
       257
       +
       }

     

       258
       258
       +
       

     

       259
       259
       +
       // TODO: update the type reflection thing to make a custom

     

       260
       260
       +
       // function type for the ISR

     

       261
       261
       +
       pub const PageFaultErrorCode = packed struct {

     

       262
       262
       +
           present: bool,

     

       263
       263
       +
           write: bool,

     

       264
       264
       +
           user: bool,

     

       265
       265
       +
           reserved_write: bool,

     

       266
       266
       +
           instruction_fetch: bool,

     

       267
       267
       +
           protection_key: bool,

     

       268
       268
       +
           shadow_stack: bool,

     

       269
       269
       +
           _reserved: u8,

     

       270
       270
       +
           sgx: bool,

     

       271
       271
       +
           _reserved2: u48,

     

       272
       272
       +
       

     

       273
       273
       +
           pub fn val(self: *const PageFaultErrorCode) u64 {

     

       274
       274
       +
               return @bitCast(self.*);

     

       275
       275
       +
           }

     

       276
       276
       +
       };

     

       277
       277
       +
       pub fn page_fault(stack_frame: *arch.structures.Idt.InterruptStackFrame, err_code_u64: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       278
       278
       +
           const err_code: PageFaultErrorCode = @bitCast(err_code_u64);

     

       279
       279
       +
           log.err("PAGE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code.val() });

     

       280
       280
       +
           const cr2 = arch.registers.ControlRegisters.Cr2.read();

     

       281
       281
       +
           switch (err_code.write) {

     

       282
       282
       +
               true => log.err("Tried to write to vaddr 0x{x:0>16}", .{cr2}),

     

       283
       283
       +
               false => log.err("Tried to read from vaddr 0x{x:0>16}", .{cr2}),

     

       284
       284
       +
           }

     

       285
       285
       +
           log.err("dying...", .{});

     

       286
       286
       +
           arch.instructions.die();

     

       287
       287
       +
       }

     

       288
       288
       +
       

     

       289
       289
       +
       pub fn breakpoint_handler(stack_frame: *Idt.InterruptStackFrame) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       290
       290
       +
           log.warn("Breakpoint @ 0x{x:0>16}, returning execution...", .{stack_frame.instruction_pointer});

     

       291
       291
       +
       }

     

       292
       292
       +
       

     

       293
       293
       +
       pub fn gpf(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       294
       294
       +
           log.warn("gpf @ 0x{x:0>16} ERR CODE {}, returning execution...", .{ stack_frame.instruction_pointer, err_code });

     

       295
       295
       +
           arch.instructions.die();

     

       296
       296
       +
       }

     

       297
       297
       +
       

     

       298
       298
       +
       pub fn double_fault(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) noreturn {

     

       299
       299
       +
           common.init_data.console.?.setColor(0xf40d17, 0);

     

       300
       300
       +
           log.err("FATAL DOUBLE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code });

     

       301
       301
       +
           log.err("dying...", .{});

     

       302
       302
       +
           arch.instructions.die();

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

       305
       305
       +
       fn bootstrapAPs() void {

     

       306
       306
       +
           log.info("Bootstrapping APs...", .{});

     

       307
       307
       +
           const cpus = limine_requests.mp.response.?.getCpus();

     

       308
       308
       +
           for (cpus) |cpu| {

     

       309
       309
       +
               cpu.goto_address = ap_init;

     

       310
       310
       +
           }

     

       311
       311
       +
       }

     

       312
       312
       +
       

     

       313
       313
       +
       fn ap_init(mp_info: *limine.SmpMpFeature.MpInfo) callconv(.c) noreturn {

     

       314
       314
       +
           // Set up the IDT

     

       315
       315
       +
           const idt_addr: usize = @intFromPtr(per_cpu_init_data.idt);

     

       316
       316
       +
           const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       317
       317
       +
           reg.load();

     

       318
       318
       +
       

     

       319
       319
       +
           // Set up our GDT and TSS

     

       320
       320
       +
           const gdt = &per_cpu_init_data.gdt_buf[mp_info.processor_id];

     

       321
       321
       +
           gdt.* = .{};

     

       322
       322
       +
           const tss = &per_cpu_init_data.tss_buf[mp_info.processor_id];

     

       323
       323
       +
           tss.* = .{};

     

       324
       324
       +
       

     

       325
       325
       +
           gdt.tss_desc.set_tss_addr(tss);

     

       326
       326
       +
           gdt.load();

     

       327
       327
       +
       

     

       328
       328
       +
           log.info("CPU {}: setup GDT and TSS, killing myself rn...", .{mp_info.processor_id});

     

       329
       329
       +
       

     

       330
       330
       +
           arch.instructions.die();

     

       331
       331
       +
       }

     

       332
       332
       +
       

     

       333
       333
       +
       const PerCpuInitData = struct {

     

       334
       334
       +
           gdt_buf: []StandardGdt = undefined,

     

       335
       335
       +
           tss_buf: []Tss = undefined,

     

       336
       336
       +
           idt: *Idt = undefined,

     

       337
       337
       +
       

     

       338
       338
       +
           const Self = @This();

     

       339
       339
       +
           pub fn init(self: *Self) void {

     

       340
       340
       +
               // 1. Allocate an IDT

     

       341
       341
       +
               const idt_addr = common.init_data.bootmem.allocMem(@sizeOf(Idt)) catch |err| {

     

       342
       342
       +
                   std.log.err("init PerCpuInitData: IDT alloc failed: {}", .{err});

     

       343
       343
       +
                   @panic("rip bozo");

     

       344
       344
       +
               };

     

       345
       345
       +
               self.idt = @ptrFromInt(idt_addr);

     

       346
       346
       +
       

     

       347
       347
       +
               // 2. Allocate space for GDT and TSS data

     

       348
       348
       +
               const cpu_count = limine_requests.mp.response.?.cpu_count;

     

       349
       349
       +
               const gdt_size = @sizeOf(StandardGdt);

     

       350
       350
       +
               const tss_size = @sizeOf(Tss);

     

       351
       351
       +
       

     

       352
       352
       +
               const total_required_size = gdt_size * cpu_count + tss_size * cpu_count;

     

       353
       353
       +
               const buf: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(total_required_size) catch |err| {

     

       354
       354
       +
                   std.log.err("init PerCpuInitData: GDT/TSS alloc failed: {}", .{err});

     

       355
       355
       +
                   @panic("rip bozo");

     

       356
       356
       +
               });

     

       357
       357
       +
       

     

       358
       358
       +
               // 3. Transmute and fill out the structure

     

       359
       359
       +
               const gdt_buf: [*]StandardGdt = @ptrCast(@alignCast(buf[0 .. gdt_size * cpu_count]));

     

       360
       360
       +
               const tss_buf: [*]Tss = @ptrCast(@alignCast(buf[gdt_size * cpu_count ..][0 .. tss_size * cpu_count]));

     

       361
       361
       +
               self.gdt_buf = gdt_buf[0..cpu_count];

     

       362
       362
       +
               self.tss_buf = tss_buf[0..cpu_count];

     

       363
       363
       +
           }

     

       364
       364
       +
       };

components/ukernel/arch/amd64/instructions.zig

···

       1
       1
       +
       pub inline fn die() noreturn {

     

       2
       2
       +
           while (true) {

     

       3
       3
       +
               asm volatile ("hlt");

     

       4
       4
       +
           }

     

       5
       5
       +
       }

+52

components/ukernel/arch/amd64/linker.ld

···

       1
       1
       +
       OUTPUT_FORMAT(elf64-x86-64)

     

       2
       2
       +
       ENTRY(_start)

     

       3
       3
       +
       

     

       4
       4
       +
       PHDRS {

     

       5
       5
       +
           limine_reqs PT_LOAD;

     

       6
       6
       +
           text    PT_LOAD;

     

       7
       7
       +
           rodata  PT_LOAD;

     

       8
       8
       +
           data    PT_LOAD;

     

       9
       9
       +
           dynamic PT_DYNAMIC;

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       SECTIONS {

     

       13
       13
       +
           . = 0xffffffff80000000;

     

       14
       14
       +
       

     

       15
       15
       +
           .limine_reqs : {

     

       16
       16
       +
               KEEP(*(.limine_reqs_start))

     

       17
       17
       +
               KEEP(*(.limine_reqs))

     

       18
       18
       +
               KEEP(*(.limine_reqs_end))

     

       19
       19
       +
           } : limine_reqs

     

       20
       20
       +
       

     

       21
       21
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       22
       22
       +
       

     

       23
       23
       +
           .text : {

     

       24
       24
       +
               *(.text .text.*)

     

       25
       25
       +
           } :text

     

       26
       26
       +
       

     

       27
       27
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       28
       28
       +
       

     

       29
       29
       +
           .rodata : {

     

       30
       30
       +
               *(.rodata .rodata.*)

     

       31
       31
       +
           } :rodata

     

       32
       32
       +
       

     

       33
       33
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       34
       34
       +
       

     

       35
       35
       +
           .data : {

     

       36
       36
       +
               *(.data .data.*)

     

       37
       37
       +
           } :data

     

       38
       38
       +
       

     

       39
       39
       +
           .dynamic : {

     

       40
       40
       +
             *(.dynamic)

     

       41
       41
       +
           } :data :dynamic

     

       42
       42
       +
       

     

       43
       43
       +
           .bss : {

     

       44
       44
       +
               *(.bss .bss.*)

     

       45
       45
       +
               *(COMMON)

     

       46
       46
       +
           } :data

     

       47
       47
       +
       

     

       48
       48
       +
           /DISCARD/ : {

     

       49
       49
       +
               *(.eh_frame*)

     

       50
       50
       +
               *(.note .note.*)

     

       51
       51
       +
           }

     

       52
       52
       +
       }

+279

components/ukernel/arch/amd64/mm/paging.zig

···

       1
       1
       +
       const common = @import("common");

     

       2
       2
       +
       const arch = @import("../root.zig");

     

       3
       3
       +
       const std = @import("std");

     

       4
       4
       +
       const physToVirt = common.mm.physToHHDM;

     

       5
       5
       +
       const Perms = common.mm.paging.Perms;

     

       6
       6
       +
       

     

       7
       7
       +
       pub const page_sizes = [_]usize{

     

       8
       8
       +
           0x1000, // 4K

     

       9
       9
       +
           0x200000, // 2M

     

       10
       10
       +
           0x40000000, // 1G

     

       11
       11
       +
           0x8000000000, // 512G

     

       12
       12
       +
           0x1000000000000, // 256T

     

       13
       13
       +
       };

     

       14
       14
       +
       

     

       15
       15
       +
       pub const PageTable = extern struct {

     

       16
       16
       +
           entries: [512]Entry,

     

       17
       17
       +
       

     

       18
       18
       +
           pub const Entry = packed struct {

     

       19
       19
       +
               present: bool,

     

       20
       20
       +
               writable: bool,

     

       21
       21
       +
               user_accessible: bool,

     

       22
       22
       +
               write_through: bool,

     

       23
       23
       +
               disable_cache: bool,

     

       24
       24
       +
               accessed: bool,

     

       25
       25
       +
               dirty: bool,

     

       26
       26
       +
               huge: bool,

     

       27
       27
       +
               global: bool,

     

       28
       28
       +
               idk: u3,

     

       29
       29
       +
               phys_addr: u40,

     

       30
       30
       +
               idk2: u11,

     

       31
       31
       +
               nx: bool,

     

       32
       32
       +
       

     

       33
       33
       +
               const Self = @This();

     

       34
       34
       +
       

     

       35
       35
       +
               pub fn getAddr(self: *const Self) u64 {

     

       36
       36
       +
                   return self.phys_addr << 12;

     

       37
       37
       +
               }

     

       38
       38
       +
       

     

       39
       39
       +
               pub fn setAddr(self: *Self, phys_addr: u64) void {

     

       40
       40
       +
                   const addr = phys_addr >> 12;

     

       41
       41
       +
                   self.phys_addr = @truncate(addr);

     

       42
       42
       +
               }

     

       43
       43
       +
           };

     

       44
       44
       +
       };

     

       45
       45
       +
       

     

       46
       46
       +
       fn extract_index_from_vaddr(vaddr: u64, level: u6) u9 {

     

       47
       47
       +
           const shamt = 12 + level * 9;

     

       48
       48
       +
           return @truncate(vaddr >> shamt);

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       pub const TypedPTE = union(common.mm.paging.PTEType) {

     

       52
       52
       +
           Mapping: MappingHandle,

     

       53
       53
       +
           Table: TableHandle,

     

       54
       54
       +
           Empty,

     

       55
       55
       +
       

     

       56
       56
       +
           const Self = @This();

     

       57
       57
       +
       

     

       58
       58
       +
           pub fn decode(pte: *PageTable.Entry, level: u3) Self {

     

       59
       59
       +
               if (!pte.present) {

     

       60
       60
       +
                   return .Empty;

     

       61
       61
       +
               }

     

       62
       62
       +
               if (!pte.huge and level != 0) {

     

       63
       63
       +
                   return .{ .Table = decode_table(pte, level) };

     

       64
       64
       +
               }

     

       65
       65
       +
               return .{ .Mapping = decode_mapping(pte, level) };

     

       66
       66
       +
           }

     

       67
       67
       +
       

     

       68
       68
       +
           pub fn decode_table(pte: *PageTable.Entry, level: u3) TableHandle {

     

       69
       69
       +
               return .{

     

       70
       70
       +
                   .phys_addr = pte.getAddr(),

     

       71
       71
       +
                   .level = level,

     

       72
       72
       +
                   .underlying = pte,

     

       73
       73
       +
                   .perms = .{

     

       74
       74
       +
                       .writable = pte.writable,

     

       75
       75
       +
                       .executable = !pte.nx,

     

       76
       76
       +
                       .userspace_accessible = pte.user_accessible,

     

       77
       77
       +
                   },

     

       78
       78
       +
               };

     

       79
       79
       +
           }

     

       80
       80
       +
       

     

       81
       81
       +
           pub fn decode_mapping(pte: *PageTable.Entry, level: u3) MappingHandle {

     

       82
       82
       +
               return .{

     

       83
       83
       +
                   .phys_addr = pte.getAddr(),

     

       84
       84
       +
                   .level = level,

     

       85
       85
       +
                   // TODO: memory types

     

       86
       86
       +
                   .memory_type = null,

     

       87
       87
       +
                   .underlying = pte,

     

       88
       88
       +
                   .perms = .{

     

       89
       89
       +
                       .writable = pte.writable,

     

       90
       90
       +
                       .executable = !pte.nx,

     

       91
       91
       +
                       .userspace_accessible = pte.user_accessible,

     

       92
       92
       +
                   },

     

       93
       93
       +
               };

     

       94
       94
       +
           }

     

       95
       95
       +
       };

     

       96
       96
       +
       

     

       97
       97
       +
       pub const MappingHandle = struct {

     

       98
       98
       +
           phys_addr: usize,

     

       99
       99
       +
           level: u3,

     

       100
       100
       +
           memory_type: ?MemoryType,

     

       101
       101
       +
           perms: Perms,

     

       102
       102
       +
           underlying: *PageTable.Entry,

     

       103
       103
       +
       };

     

       104
       104
       +
       

     

       105
       105
       +
       pub const TableHandle = struct {

     

       106
       106
       +
           phys_addr: usize,

     

       107
       107
       +
           level: u3,

     

       108
       108
       +
           perms: Perms,

     

       109
       109
       +
           underlying: ?*PageTable.Entry,

     

       110
       110
       +
       

     

       111
       111
       +
           const Self = @This();

     

       112
       112
       +
       

     

       113
       113
       +
           // Get the child entries of this page table

     

       114
       114
       +
           pub fn get_children(self: *const Self) []PageTable.Entry {

     

       115
       115
       +
               const page_table = physToVirt(*PageTable, self.phys_addr);

     

       116
       116
       +
               return page_table.entries[0..];

     

       117
       117
       +
           }

     

       118
       118
       +
       

     

       119
       119
       +
           // Get children from the position holding the table and on

     

       120
       120
       +
           pub fn skip_to(self: *const Self, vaddr: usize) []PageTable.Entry {

     

       121
       121
       +
               return self.get_children()[extract_index_from_vaddr(vaddr, self.level - 1)..];

     

       122
       122
       +
           }

     

       123
       123
       +
       

     

       124
       124
       +
           // Decode child table given an entry

     

       125
       125
       +
           pub fn decode_child(self: *const Self, pte: *PageTable.Entry) TypedPTE {

     

       126
       126
       +
               return TypedPTE.decode(pte, self.level - 1);

     

       127
       127
       +
           }

     

       128
       128
       +
       

     

       129
       129
       +
           pub fn addPerms(self: *const Self, perms: Perms) void {

     

       130
       130
       +
               if (perms.executable) {

     

       131
       131
       +
                   self.underlying.?.nx = false;

     

       132
       132
       +
               }

     

       133
       133
       +
               if (perms.writable) {

     

       134
       134
       +
                   self.underlying.?.writable = true;

     

       135
       135
       +
               }

     

       136
       136
       +
               if (perms.userspace_accessible) {

     

       137
       137
       +
                   self.underlying.?.user_accessible = true;

     

       138
       138
       +
               }

     

       139
       139
       +
           }

     

       140
       140
       +
       

     

       141
       141
       +
           pub fn child_domain(self: *const Self, vaddr: usize) UntypedSlice {

     

       142
       142
       +
               return domain(vaddr, self.level - 1);

     

       143
       143
       +
           }

     

       144
       144
       +
       

     

       145
       145
       +
           pub fn make_child_table(self: *const Self, pte: *PageTable.Entry, perms: Perms) !TableHandle {

     

       146
       146
       +
               const pmem = try make_page_table();

     

       147
       147
       +
       

     

       148
       148
       +
               const result: TableHandle = .{

     

       149
       149
       +
                   .phys_addr = pmem,

     

       150
       150
       +
                   .level = self.level - 1,

     

       151
       151
       +
                   .perms = perms,

     

       152
       152
       +
                   .underlying = pte,

     

       153
       153
       +
               };

     

       154
       154
       +
               pte.* = encode_table(result);

     

       155
       155
       +
       

     

       156
       156
       +
               return result;

     

       157
       157
       +
           }

     

       158
       158
       +
       

     

       159
       159
       +
           pub fn make_child_mapping(

     

       160
       160
       +
               self: *const Self,

     

       161
       161
       +
               pte: *PageTable.Entry,

     

       162
       162
       +
               paddr: ?usize,

     

       163
       163
       +
               perms: Perms,

     

       164
       164
       +
               memory_type: MemoryType,

     

       165
       165
       +
           ) !MappingHandle {

     

       166
       166
       +
               const page_size = page_sizes[self.level - 1];

     

       167
       167
       +
               const pmem = paddr orelse try common.init_data.bootmem.allocPhys(page_size);

     

       168
       168
       +
       

     

       169
       169
       +
               const result: MappingHandle = .{

     

       170
       170
       +
                   .level = self.level - 1,

     

       171
       171
       +
                   .memory_type = memory_type,

     

       172
       172
       +
                   .perms = perms,

     

       173
       173
       +
                   .underlying = pte,

     

       174
       174
       +
                   .phys_addr = pmem,

     

       175
       175
       +
               };

     

       176
       176
       +
       

     

       177
       177
       +
               pte.* = encode_mapping(result);

     

       178
       178
       +
       

     

       179
       179
       +
               return result;

     

       180
       180
       +
           }

     

       181
       181
       +
       };

     

       182
       182
       +
       

     

       183
       183
       +
       pub fn root_table(vaddr: usize) TableHandle {

     

       184
       184
       +
           _ = vaddr;

     

       185
       185
       +
           const cr3_val = arch.registers.ControlRegisters.Cr3.read() & 0xFFFF_FFFF_FFFF_F000;

     

       186
       186
       +
           return .{

     

       187
       187
       +
               .phys_addr = cr3_val,

     

       188
       188
       +
               // TODO: detect and support 5 level paging!

     

       189
       189
       +
               .level = 4,

     

       190
       190
       +
               .perms = .{

     

       191
       191
       +
                   .executable = true,

     

       192
       192
       +
                   .writable = true,

     

       193
       193
       +
               },

     

       194
       194
       +
               .underlying = null,

     

       195
       195
       +
           };

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       fn encode_table(pte_handle: TableHandle) PageTable.Entry {

     

       199
       199
       +
           var pte = std.mem.zeroes(PageTable.Entry);

     

       200
       200
       +
       

     

       201
       201
       +
           pte.setAddr(pte_handle.phys_addr);

     

       202
       202
       +
           pte.writable = pte_handle.perms.writable;

     

       203
       203
       +
           pte.user_accessible = pte_handle.perms.userspace_accessible;

     

       204
       204
       +
           pte.nx = !pte_handle.perms.executable;

     

       205
       205
       +
           pte.present = true;

     

       206
       206
       +
           pte.huge = false;

     

       207
       207
       +
       

     

       208
       208
       +
           return pte;

     

       209
       209
       +
       }

     

       210
       210
       +
       

     

       211
       211
       +
       fn encode_mapping(pte_handle: MappingHandle) PageTable.Entry {

     

       212
       212
       +
           var pte = std.mem.zeroes(PageTable.Entry);

     

       213
       213
       +
       

     

       214
       214
       +
           pte.setAddr(pte_handle.phys_addr);

     

       215
       215
       +
           pte.present = true;

     

       216
       216
       +
       

     

       217
       217
       +
           if (pte_handle.level != 0) {

     

       218
       218
       +
               pte.huge = true;

     

       219
       219
       +
           }

     

       220
       220
       +
       

     

       221
       221
       +
           pte.writable = pte_handle.perms.writable;

     

       222
       222
       +
           pte.user_accessible = pte_handle.perms.userspace_accessible;

     

       223
       223
       +
           pte.nx = !pte_handle.perms.executable;

     

       224
       224
       +
       

     

       225
       225
       +
           encode_memory_type(&pte, pte_handle);

     

       226
       226
       +
       

     

       227
       227
       +
           return pte;

     

       228
       228
       +
       }

     

       229
       229
       +
       

     

       230
       230
       +
       fn encode_memory_type(pte: *PageTable.Entry, pte_handle: MappingHandle) void {

     

       231
       231
       +
           const mt = pte_handle.memory_type orelse @panic("Unknown memory type");

     

       232
       232
       +
       

     

       233
       233
       +
           // TODO: Page Attribute Table

     

       234
       234
       +
           switch (mt) {

     

       235
       235
       +
               .MemoryWritethrough => pte.write_through = true,

     

       236
       236
       +
               .DeviceUncacheable => pte.disable_cache = true,

     

       237
       237
       +
               .MemoryWriteBack => {},

     

       238
       238
       +
               else => @panic("Cannot set memory type"),

     

       239
       239
       +
           }

     

       240
       240
       +
       }

     

       241
       241
       +
       

     

       242
       242
       +
       /// Returns physical address

     

       243
       243
       +
       fn make_page_table() !usize {

     

       244
       244
       +
           const pt_phys = try common.init_data.bootmem.allocPhys(std.heap.pageSize());

     

       245
       245
       +
           const pt = physToVirt([*]u8, pt_phys);

     

       246
       246
       +
           @memset(pt[0..std.heap.pageSize()], 0x00);

     

       247
       247
       +
           return pt_phys;

     

       248
       248
       +
       }

     

       249
       249
       +
       

     

       250
       250
       +
       pub fn invalidate(vaddr: u64) void {

     

       251
       251
       +
           asm volatile (

     

       252
       252
       +
               \\ invlpg (%[vaddr])

     

       253
       253
       +
               :

     

       254
       254
       +
               : [vaddr] "r" (vaddr),

     

       255
       255
       +
               : .{ .memory = true });

     

       256
       256
       +
       }

     

       257
       257
       +
       

     

       258
       258
       +
       const UntypedSlice = struct {

     

       259
       259
       +
           len: usize,

     

       260
       260
       +
           ptr: usize,

     

       261
       261
       +
       };

     

       262
       262
       +
       

     

       263
       263
       +
       pub fn domain(vaddr: usize, level: u3) UntypedSlice {

     

       264
       264
       +
           return .{

     

       265
       265
       +
               .len = page_sizes[level],

     

       266
       266
       +
               .ptr = vaddr & ~(page_sizes[level] - 1),

     

       267
       267
       +
           };

     

       268
       268
       +
       }

     

       269
       269
       +
       

     

       270
       270
       +
       pub const MemoryType = enum {

     

       271
       271
       +
           DeviceUncacheable,

     

       272
       272
       +
           DeviceWriteCombining,

     

       273
       273
       +
           MemoryWritethrough,

     

       274
       274
       +
           MemoryWriteBack,

     

       275
       275
       +
       };

     

       276
       276
       +
       

     

       277
       277
       +
       pub fn can_map_at(level: u3) bool {

     

       278
       278
       +
           return level < 2;

     

       279
       279
       +
       }

components/ukernel/arch/amd64/mm/root.zig

···

       1
       1
       +
       pub const paging = @import("paging.zig");

+95

components/ukernel/arch/amd64/registers.zig

···

       1
       1
       +
       pub fn ControlRegister(comptime T: type, comptime reg: []const u8) type {

     

       2
       2
       +
           return struct {

     

       3
       3
       +
               pub fn read() T {

     

       4
       4
       +
                   return asm volatile ("mov %%" ++ reg ++ ", %[output]"

     

       5
       5
       +
                       : [output] "=r" (-> T),

     

       6
       6
       +
                   );

     

       7
       7
       +
               }

     

       8
       8
       +
       

     

       9
       9
       +
               pub fn write(value: T) void {

     

       10
       10
       +
                   asm volatile ("mov %[input], %%" ++ reg

     

       11
       11
       +
                       :

     

       12
       12
       +
                       : [input] "r" (value),

     

       13
       13
       +
                   );

     

       14
       14
       +
               }

     

       15
       15
       +
           };

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       pub fn GeneralPurpose(comptime T: type, comptime reg: []const u8) type {

     

       19
       19
       +
           return struct {

     

       20
       20
       +
               pub fn read() T {

     

       21
       21
       +
                   return asm volatile ("mov %%" ++ reg ++ ", %[output]"

     

       22
       22
       +
                       : [output] "=r" (-> T),

     

       23
       23
       +
                   );

     

       24
       24
       +
               }

     

       25
       25
       +
       

     

       26
       26
       +
               pub fn write(value: T) void {

     

       27
       27
       +
                   asm volatile ("mov %[input], %%" ++ reg

     

       28
       28
       +
                       :

     

       29
       29
       +
                       : [input] "r" (value),

     

       30
       30
       +
                   );

     

       31
       31
       +
               }

     

       32
       32
       +
           };

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       pub fn MSR(comptime T: type, comptime num: u32) type {

     

       36
       36
       +
           return struct {

     

       37
       37
       +
               pub fn read() T {

     

       38
       38
       +
                   // TODO: switch on bit size to allow custom structs

     

       39
       39
       +
                   switch (T) {

     

       40
       40
       +
                       u32 => return asm volatile ("rdmsr"

     

       41
       41
       +
                           : [_] "={eax}" (-> u32),

     

       42
       42
       +
                           : [_] "{ecx}" (num),

     

       43
       43
       +
                       ),

     

       44
       44
       +
                       u64 => {

     

       45
       45
       +
                           var low_val: u32 = undefined;

     

       46
       46
       +
                           var high_val: u32 = undefined;

     

       47
       47
       +
                           asm volatile ("rdmsr"

     

       48
       48
       +
                               : [_] "={eax}" (low_val),

     

       49
       49
       +
                                 [_] "={edx}" (high_val),

     

       50
       50
       +
                               : [_] "{ecx}" (num),

     

       51
       51
       +
                           );

     

       52
       52
       +
                           return (@as(u64, high_val) << 32) | @as(u64, low_val);

     

       53
       53
       +
                       },

     

       54
       54
       +
                       else => @compileError("Unimplemented for type"),

     

       55
       55
       +
                   }

     

       56
       56
       +
               }

     

       57
       57
       +
               pub fn write(value: T) void {

     

       58
       58
       +
                   switch (T) {

     

       59
       59
       +
                       u32 => asm volatile ("wrmsr"

     

       60
       60
       +
                           :

     

       61
       61
       +
                           : [_] "{eax}" (value),

     

       62
       62
       +
                             [_] "{edx}" (@as(u32, 0)),

     

       63
       63
       +
                             [_] "{ecx}" (num),

     

       64
       64
       +
                       ),

     

       65
       65
       +
                       u64 => {

     

       66
       66
       +
                           const low_val: u32 = @truncate(value);

     

       67
       67
       +
                           const high_val: u32 = @truncate(value >> 32);

     

       68
       68
       +
                           asm volatile ("wrmsr"

     

       69
       69
       +
                               :

     

       70
       70
       +
                               : [_] "{eax}" (low_val),

     

       71
       71
       +
                                 [_] "{edx}" (high_val),

     

       72
       72
       +
                                 [_] "{ecx}" (num),

     

       73
       73
       +
                           );

     

       74
       74
       +
                       },

     

       75
       75
       +
                       else => @compileError("Unimplemented for type"),

     

       76
       76
       +
                   }

     

       77
       77
       +
               }

     

       78
       78
       +
           };

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       pub const ControlRegisters = struct {

     

       82
       82
       +
           pub const Cr0 = ControlRegister(u64, "cr0");

     

       83
       83
       +
           pub const Cr2 = ControlRegister(u64, "cr2");

     

       84
       84
       +
           pub const Cr3 = ControlRegister(u64, "cr3");

     

       85
       85
       +
           pub const Cr4 = ControlRegister(u64, "cr4");

     

       86
       86
       +
       };

     

       87
       87
       +
       

     

       88
       88
       +
       pub const Segmentation = struct {

     

       89
       89
       +
           pub const Cs = GeneralPurpose(u16, "cs");

     

       90
       90
       +
           pub const Ds = GeneralPurpose(u16, "ds");

     

       91
       91
       +
           pub const Ss = GeneralPurpose(u16, "ss");

     

       92
       92
       +
           pub const Es = GeneralPurpose(u16, "es");

     

       93
       93
       +
           pub const Fs = GeneralPurpose(u16, "fs");

     

       94
       94
       +
           pub const Gs = GeneralPurpose(u16, "gs");

     

       95
       95
       +
       };

+24

components/ukernel/arch/amd64/root.zig

···

       1
       1
       +
       pub const boot = @import("boot.zig");

     

       2
       2
       +
       pub const instructions = @import("instructions.zig");

     

       3
       3
       +
       pub const mm = @import("mm/root.zig");

     

       4
       4
       +
       pub const structures = @import("structures/root.zig");

     

       5
       5
       +
       pub const registers = @import("registers.zig");

     

       6
       6
       +
       const common = @import("common");

     

       7
       7
       +
       const std = @import("std");

     

       8
       8
       +
       

     

       9
       9
       +
       fn pageSize() usize {

     

       10
       10
       +
           return 4 << 10;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       pub const std_options: std.Options = .{

     

       14
       14
       +
           .logFn = common.aux.logFn,

     

       15
       15
       +
           .page_size_min = 4 << 10,

     

       16
       16
       +
           .page_size_max = 4 << 10,

     

       17
       17
       +
           .queryPageSize = pageSize,

     

       18
       18
       +
       };

     

       19
       19
       +
       pub const panic = std.debug.FullPanic(common.aux.panic);

     

       20
       20
       +
       

     

       21
       21
       +
       comptime {

     

       22
       22
       +
           // Entry point (_start)

     

       23
       23
       +
           @export(&boot.bsp_init, .{ .name = "_start", .linkage = .strong });

     

       24
       24
       +
       }

+170

components/ukernel/arch/amd64/structures/Idt.zig

···

       1
       1
       +
       //! The entire Interrupt Descriptor Table (IDT) structure for AMD64,

     

       2
       2
       +
       //! including all the necessary ISR entries. Each of the defined

     

       3
       3
       +
       //! ISRs is meant for a specific type of exception, while the

     

       4
       4
       +
       //! array at the end of the IDT can be used for whatever is necessary.

     

       5
       5
       +
       const std = @import("std");

     

       6
       6
       +
       const arch = @import("../root.zig");

     

       7
       7
       +
       const StandardGdt = arch.structures.gdt.StandardGdt;

     

       8
       8
       +
       

     

       9
       9
       +
       /// Faulty division (mostly divide by zero)

     

       10
       10
       +
       divide_error: Entry(.handler),

     

       11
       11
       +
       /// AMD64 Debug Exception, either a fault or a trap

     

       12
       12
       +
       debug_exception: Entry(.handler),

     

       13
       13
       +
       /// Non Maskable Interrupt

     

       14
       14
       +
       non_maskable_interrupt: Entry(.handler),

     

       15
       15
       +
       /// Breakpoint (int3) trap

     

       16
       16
       +
       breakpoint: Entry(.handler),

     

       17
       17
       +
       /// Overflow trap (INTO instruction)

     

       18
       18
       +
       overflow: Entry(.handler),

     

       19
       19
       +
       /// Bound Range Exception (BOUND instruction)

     

       20
       20
       +
       bound_range_exceeded: Entry(.handler),

     

       21
       21
       +
       /// Invalid Opcode Exception

     

       22
       22
       +
       invalid_opcode: Entry(.handler),

     

       23
       23
       +
       /// Device Not Available (FPU instructions when FPU disabled)

     

       24
       24
       +
       device_not_available: Entry(.handler),

     

       25
       25
       +
       /// Double Fault Exception

     

       26
       26
       +
       double_fault: Entry(.abort_with_err_code),

     

       27
       27
       +
       _coprocessor_segment_overrun: Entry(.handler),

     

       28
       28
       +
       /// Invalid TSS: bad segment selector

     

       29
       29
       +
       invalid_tss: Entry(.handler_with_err_code),

     

       30
       30
       +
       /// Segment Not Present

     

       31
       31
       +
       segment_not_present: Entry(.handler_with_err_code),

     

       32
       32
       +
       /// Stack Segment Fault

     

       33
       33
       +
       stack_segment_fault: Entry(.handler_with_err_code),

     

       34
       34
       +
       /// General Protection Fault

     

       35
       35
       +
       general_protection_fault: Entry(.handler_with_err_code),

     

       36
       36
       +
       /// Page Fault

     

       37
       37
       +
       page_fault: Entry(.handler_with_err_code),

     

       38
       38
       +
       

     

       39
       39
       +
       _reserved1: Entry(.handler),

     

       40
       40
       +
       /// x87 Floating Point Exception

     

       41
       41
       +
       x87_floating_point: Entry(.handler),

     

       42
       42
       +
       /// Alignment Check Exception

     

       43
       43
       +
       alignment_check: Entry(.handler_with_err_code),

     

       44
       44
       +
       /// Machine Check Exception (MCE)

     

       45
       45
       +
       machine_check: Entry(.abort),

     

       46
       46
       +
       /// SIMD Floating Point Exception

     

       47
       47
       +
       simd_floating_point: Entry(.handler),

     

       48
       48
       +
       /// Virtualization Exception

     

       49
       49
       +
       virtualization: Entry(.handler),

     

       50
       50
       +
       /// Control Protection Exception

     

       51
       51
       +
       control_protection: Entry(.handler_with_err_code),

     

       52
       52
       +
       _reserved2: [10]Entry(.handler),

     

       53
       53
       +
       /// User Accessible Interrupts

     

       54
       54
       +
       interrupts: [256 - 32]Entry(.handler),

     

       55
       55
       +
       

     

       56
       56
       +
       /// An ISR Entry in the IDT

     

       57
       57
       +
       pub const EntryType = union(enum) {

     

       58
       58
       +
           abort: void,

     

       59
       59
       +
           abort_with_err_code: void,

     

       60
       60
       +
           handler: void,

     

       61
       61
       +
           handler_with_err_code: void,

     

       62
       62
       +
           handler_with_custom_err_code: type,

     

       63
       63
       +
       };

     

       64
       64
       +
       pub fn Entry(comptime entry_type: EntryType) type {

     

       65
       65
       +
           const return_type = switch (entry_type) {

     

       66
       66
       +
               .abort, .abort_with_err_code => noreturn,

     

       67
       67
       +
               .handler, .handler_with_err_code, .handler_with_custom_err_code => void,

     

       68
       68
       +
           };

     

       69
       69
       +
           const params: []const std.builtin.Type.Fn.Param = switch (entry_type) {

     

       70
       70
       +
               .handler, .abort => &.{

     

       71
       71
       +
                   // Interrupt stack frame

     

       72
       72
       +
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       73
       73
       +
               },

     

       74
       74
       +
               .handler_with_err_code, .abort_with_err_code => &.{

     

       75
       75
       +
                   // Interrupt stack frame

     

       76
       76
       +
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       77
       77
       +
                   // Error code

     

       78
       78
       +
                   .{ .is_generic = false, .is_noalias = false, .type = u64 },

     

       79
       79
       +
               },

     

       80
       80
       +
               .handler_with_custom_err_code => |err_code_type| &.{

     

       81
       81
       +
                   // Interrupt stack frame

     

       82
       82
       +
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       83
       83
       +
                   // Custom Error code

     

       84
       84
       +
                   .{ .is_generic = false, .is_noalias = false, .type = err_code_type },

     

       85
       85
       +
               },

     

       86
       86
       +
           };

     

       87
       87
       +
           const FunctionTypeInfo: std.builtin.Type = .{

     

       88
       88
       +
               .@"fn" = .{

     

       89
       89
       +
                   .calling_convention = .{ .x86_64_interrupt = .{} },

     

       90
       90
       +
                   .is_generic = false,

     

       91
       91
       +
                   .is_var_args = false,

     

       92
       92
       +
                   .return_type = return_type,

     

       93
       93
       +
                   .params = params,

     

       94
       94
       +
               },

     

       95
       95
       +
           };

     

       96
       96
       +
       

     

       97
       97
       +
           // The actual IDT entry structure

     

       98
       98
       +
           return extern struct {

     

       99
       99
       +
               func_low: u16,

     

       100
       100
       +
               gdt_selector: u16,

     

       101
       101
       +
               options: Options,

     

       102
       102
       +
               func_mid: u16,

     

       103
       103
       +
               func_high: u32,

     

       104
       104
       +
               _reserved: u32 = 0,

     

       105
       105
       +
       

     

       106
       106
       +
               const FuncType = @Type(FunctionTypeInfo);

     

       107
       107
       +
       

     

       108
       108
       +
               pub const Options = packed struct {

     

       109
       109
       +
                   /// Interrupt Stack Table Index

     

       110
       110
       +
                   ist_index: u3,

     

       111
       111
       +
                   _reserved: u5 = 0,

     

       112
       112
       +
                   disable_interrupts: bool,

     

       113
       113
       +
                   must_be_one: u3 = 0b111,

     

       114
       114
       +
                   must_be_zero: u1 = 0,

     

       115
       115
       +
                   /// Descriptor Privilege Level

     

       116
       116
       +
                   dpl: u2,

     

       117
       117
       +
                   present: bool,

     

       118
       118
       +
               };

     

       119
       119
       +
       

     

       120
       120
       +
               const Self = @This();

     

       121
       121
       +
       

     

       122
       122
       +
               pub fn installHandler(self: *Self, func: *const FuncType) void {

     

       123
       123
       +
                   // Fetch the Code Segment

     

       124
       124
       +
                   const func_ptr = @intFromPtr(func);

     

       125
       125
       +
                   self.* = .{

     

       126
       126
       +
                       // Set the function pointer

     

       127
       127
       +
                       .func_low = @truncate(func_ptr & 0xFFFF),

     

       128
       128
       +
                       .func_mid = @truncate((func_ptr >> 16) & 0xFFFF),

     

       129
       129
       +
                       .func_high = @truncate((func_ptr >> 32) & 0xFFFF_FFFF),

     

       130
       130
       +
                       .gdt_selector = StandardGdt.selectors.kernel_code,

     

       131
       131
       +
                       .options = .{

     

       132
       132
       +
                           // No Interrupt Stack Table yet

     

       133
       133
       +
                           .ist_index = 0,

     

       134
       134
       +
                           // Mask interrupts while running ISR handler

     

       135
       135
       +
                           .disable_interrupts = true,

     

       136
       136
       +
                           // Ring 3 Minimum privilege level

     

       137
       137
       +
                           .dpl = 3,

     

       138
       138
       +
                           // Mark as present

     

       139
       139
       +
                           .present = true,

     

       140
       140
       +
                       },

     

       141
       141
       +
                   };

     

       142
       142
       +
               }

     

       143
       143
       +
           };

     

       144
       144
       +
       }

     

       145
       145
       +
       

     

       146
       146
       +
       /// IDT Register

     

       147
       147
       +
       pub const Idtr = packed struct {

     

       148
       148
       +
           limit: u16,

     

       149
       149
       +
           addr: u64,

     

       150
       150
       +
       

     

       151
       151
       +
           /// Load the IDT Register

     

       152
       152
       +
           pub fn load(self: *const Idtr) void {

     

       153
       153
       +
               asm volatile ("lidt (%[idtr_addr])"

     

       154
       154
       +
                   :

     

       155
       155
       +
                   : [idtr_addr] "r" (self),

     

       156
       156
       +
               );

     

       157
       157
       +
           }

     

       158
       158
       +
       };

     

       159
       159
       +
       

     

       160
       160
       +
       /// Interrupt Stack Frame

     

       161
       161
       +
       /// TODO: maybe move this somewhere else

     

       162
       162
       +
       pub const InterruptStackFrame = extern struct {

     

       163
       163
       +
           instruction_pointer: u64,

     

       164
       164
       +
           code_segment: u16,

     

       165
       165
       +
           _reserved1: [6]u8,

     

       166
       166
       +
           cpu_flags: u64,

     

       167
       167
       +
           stack_pointer: u64,

     

       168
       168
       +
           stack_segment: u16,

     

       169
       169
       +
           _reserved2: [6]u8,

     

       170
       170
       +
       };

+167

components/ukernel/arch/amd64/structures/gdt.zig

···

       1
       1
       +
       //! The Global Descriptor Table (GDT) structure for AMD64

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const arch = @import("../root.zig");

     

       4
       4
       +
       

     

       5
       5
       +
       pub const Descriptor = packed struct {

     

       6
       6
       +
           limit_low: u16 = 0,

     

       7
       7
       +
           base_low: u16 = 0,

     

       8
       8
       +
           base_mid: u8 = 0,

     

       9
       9
       +
           access: Access,

     

       10
       10
       +
           limit_high: u4 = 0,

     

       11
       11
       +
           flags: Flags = .{},

     

       12
       12
       +
           base_high: u8 = 0,

     

       13
       13
       +
       

     

       14
       14
       +
           const Self = @This();

     

       15
       15
       +
       

     

       16
       16
       +
           pub const Access = packed struct {

     

       17
       17
       +
               // Accessed

     

       18
       18
       +
               accessed: bool = true,

     

       19
       19
       +
               // Readable/Writable

     

       20
       20
       +
               rw: bool = false,

     

       21
       21
       +
               // Direction bit or Conforming bit

     

       22
       22
       +
               dc: bool = false,

     

       23
       23
       +
               // Executable

     

       24
       24
       +
               executable: bool,

     

       25
       25
       +
               // Descriptor Type bit

     

       26
       26
       +
               descriptor_type: DescriptorType = .code_or_data,

     

       27
       27
       +
               // Descriptor Privilege Level

     

       28
       28
       +
               dpl: u2,

     

       29
       29
       +
               // Present bit

     

       30
       30
       +
               p: bool = true,

     

       31
       31
       +
       

     

       32
       32
       +
               pub const DescriptorType = enum(u1) {

     

       33
       33
       +
                   tss = 0,

     

       34
       34
       +
                   code_or_data = 1,

     

       35
       35
       +
               };

     

       36
       36
       +
           };

     

       37
       37
       +
       

     

       38
       38
       +
           pub const Flags = packed struct {

     

       39
       39
       +
               // Reserved

     

       40
       40
       +
               _reserved: u1 = 0,

     

       41
       41
       +
               // Long Mode code flag

     

       42
       42
       +
               long_mode: bool = true,

     

       43
       43
       +
               // Size flag (16 vs 32)

     

       44
       44
       +
               db: DB = .protected_16,

     

       45
       45
       +
               // Granularity flag

     

       46
       46
       +
               granularity: Granularity = .byte,

     

       47
       47
       +
       

     

       48
       48
       +
               pub const Granularity = enum(u1) {

     

       49
       49
       +
                   byte = 0,

     

       50
       50
       +
                   page = 1,

     

       51
       51
       +
               };

     

       52
       52
       +
       

     

       53
       53
       +
               pub const DB = enum(u1) {

     

       54
       54
       +
                   protected_16 = 0,

     

       55
       55
       +
                   protected_32 = 1,

     

       56
       56
       +
               };

     

       57
       57
       +
           };

     

       58
       58
       +
       

     

       59
       59
       +
           pub const null_desc = std.mem.zeroes(Descriptor);

     

       60
       60
       +
           pub const kernel_code: Self = .{ .access = .{ .dpl = 0, .executable = true } };

     

       61
       61
       +
           pub const kernel_data: Self = .{ .access = .{ .dpl = 0, .executable = false, .rw = true } };

     

       62
       62
       +
           pub const user_code: Self = .{ .access = .{ .dpl = 3, .executable = true } };

     

       63
       63
       +
           pub const user_data: Self = .{ .access = .{ .dpl = 3, .executable = false, .rw = true } };

     

       64
       64
       +
       };

     

       65
       65
       +
       

     

       66
       66
       +
       pub const StandardGdt = extern struct {

     

       67
       67
       +
           null_desc: Descriptor = .null_desc,

     

       68
       68
       +
           kernel_code: Descriptor = .kernel_code,

     

       69
       69
       +
           kernel_data: Descriptor = .kernel_data,

     

       70
       70
       +
           tss_desc: TssDescriptor align(@alignOf(Descriptor)) = .{},

     

       71
       71
       +
           user_data: Descriptor = .user_data,

     

       72
       72
       +
           user_code: Descriptor = .user_code,

     

       73
       73
       +
       

     

       74
       74
       +
           pub const selectors = struct {

     

       75
       75
       +
               pub const null_desc = @offsetOf(StandardGdt, "null_desc");

     

       76
       76
       +
               pub const kernel_code = @offsetOf(StandardGdt, "kernel_code");

     

       77
       77
       +
               pub const kernel_data = @offsetOf(StandardGdt, "kernel_data");

     

       78
       78
       +
               pub const tss_desc = @offsetOf(StandardGdt, "tss_desc");

     

       79
       79
       +
               pub const user_data = @offsetOf(StandardGdt, "user_data") | 0b11;

     

       80
       80
       +
               pub const user_code = @offsetOf(StandardGdt, "user_code") | 0b11;

     

       81
       81
       +
           };

     

       82
       82
       +
       

     

       83
       83
       +
           const Self = @This();

     

       84
       84
       +
       

     

       85
       85
       +
           pub fn load(self: *Self) void {

     

       86
       86
       +
               // 1. Load the GDTR

     

       87
       87
       +
               const gdtr: Gdtr = .{

     

       88
       88
       +
                   .limit = @truncate(@sizeOf(StandardGdt) - 1),

     

       89
       89
       +
                   .base = @intFromPtr(self),

     

       90
       90
       +
               };

     

       91
       91
       +
               gdtr.load();

     

       92
       92
       +
       

     

       93
       93
       +
               // 2. Set the kernel data segments

     

       94
       94
       +
               asm volatile (

     

       95
       95
       +
                   \\ mov %[sel], %%ds

     

       96
       96
       +
                   \\ mov %[sel], %%es

     

       97
       97
       +
                   \\ mov %[sel], %%fs

     

       98
       98
       +
                   \\ mov %[sel], %%gs

     

       99
       99
       +
                   \\ mov %[sel], %%ss

     

       100
       100
       +
                   :

     

       101
       101
       +
                   : [sel] "rm" (@as(u16, selectors.kernel_data)),

     

       102
       102
       +
               );

     

       103
       103
       +
       

     

       104
       104
       +
               // 3. Reload kernel code segments (far return)

     

       105
       105
       +
               asm volatile (

     

       106
       106
       +
                   \\ push %[sel]

     

       107
       107
       +
                   \\ lea 1f(%%rip), %%rax

     

       108
       108
       +
                   \\ push %%rax

     

       109
       109
       +
                   \\ .byte 0x48, 0xcb // retfq

     

       110
       110
       +
                   \\ 1:

     

       111
       111
       +
                   :

     

       112
       112
       +
                   : [sel] "i" (@as(u16, selectors.kernel_code)),

     

       113
       113
       +
                   : .{ .rax = true });

     

       114
       114
       +
       

     

       115
       115
       +
               // 4. Set the TSS descriptor

     

       116
       116
       +
               asm volatile (

     

       117
       117
       +
                   \\ ltr %[sel]

     

       118
       118
       +
                   :

     

       119
       119
       +
                   : [sel] "r" (@as(u16, selectors.tss_desc)),

     

       120
       120
       +
               );

     

       121
       121
       +
           }

     

       122
       122
       +
       };

     

       123
       123
       +
       

     

       124
       124
       +
       pub const Gdtr = packed struct {

     

       125
       125
       +
           limit: u16,

     

       126
       126
       +
           base: u64,

     

       127
       127
       +
       

     

       128
       128
       +
           pub fn load(self: *const Gdtr) void {

     

       129
       129
       +
               asm volatile ("lgdt %[gdtr_ptr]"

     

       130
       130
       +
                   :

     

       131
       131
       +
                   : [gdtr_ptr] "*p" (self),

     

       132
       132
       +
               );

     

       133
       133
       +
           }

     

       134
       134
       +
       };

     

       135
       135
       +
       

     

       136
       136
       +
       const TssDescriptor = extern struct {

     

       137
       137
       +
           const Low = packed struct {

     

       138
       138
       +
               limit_low: u16 = 0,

     

       139
       139
       +
               base_low: u16 = 0,

     

       140
       140
       +
               base_mid: u8 = 0,

     

       141
       141
       +
               seg_type: u4 = 0b1001,

     

       142
       142
       +
               _reserved0: u1 = 0b0,

     

       143
       143
       +
               dpl: u2 = 0,

     

       144
       144
       +
               p: bool = true,

     

       145
       145
       +
               limit_high: u4 = 0,

     

       146
       146
       +
               unused: u1 = 0,

     

       147
       147
       +
               _reserved1: u2 = 0b00,

     

       148
       148
       +
               granularity: u1 = 0,

     

       149
       149
       +
               base_high: u8 = 0,

     

       150
       150
       +
           };

     

       151
       151
       +
           descriptor: Low = .{},

     

       152
       152
       +
           base_top: u32 = 0,

     

       153
       153
       +
           _reserved: u32 = 0,

     

       154
       154
       +
       

     

       155
       155
       +
           const Self = @This();

     

       156
       156
       +
       

     

       157
       157
       +
           pub fn set_tss_addr(self: *Self, tss: *const arch.structures.tss.Tss) void {

     

       158
       158
       +
               const tss_ptr: usize = @intFromPtr(tss);

     

       159
       159
       +
               // Set the base

     

       160
       160
       +
               self.descriptor.base_low = @truncate(tss_ptr);

     

       161
       161
       +
               self.descriptor.base_mid = @truncate(tss_ptr >> 16);

     

       162
       162
       +
               self.descriptor.base_high = @truncate(tss_ptr >> 24);

     

       163
       163
       +
               self.base_top = @truncate(tss_ptr >> 32);

     

       164
       164
       +
               // Set the limit

     

       165
       165
       +
               self.descriptor.limit_low = @sizeOf(arch.structures.tss.Tss);

     

       166
       166
       +
           }

     

       167
       167
       +
       };

components/ukernel/arch/amd64/structures/root.zig

···

       1
       1
       +
       pub const gdt = @import("gdt.zig");

     

       2
       2
       +
       pub const tss = @import("tss.zig");

     

       3
       3
       +
       pub const Idt = @import("Idt.zig");

+17

components/ukernel/arch/amd64/structures/tss.zig

···

       1
       1
       +
       pub const Tss = extern struct {

     

       2
       2
       +
           _reserved1: u32 = 0,

     

       3
       3
       +
           rsp0: u64 align(4) = 0,

     

       4
       4
       +
           rsp1: u64 align(4) = 0,

     

       5
       5
       +
           rsp2: u64 align(4) = 0,

     

       6
       6
       +
           _reserved2: u64 align(4) = 0,

     

       7
       7
       +
           ist1: u64 align(4) = 0,

     

       8
       8
       +
           ist2: u64 align(4) = 0,

     

       9
       9
       +
           ist3: u64 align(4) = 0,

     

       10
       10
       +
           ist4: u64 align(4) = 0,

     

       11
       11
       +
           ist5: u64 align(4) = 0,

     

       12
       12
       +
           ist6: u64 align(4) = 0,

     

       13
       13
       +
           ist7: u64 align(4) = 0,

     

       14
       14
       +
           _reserved3: u64 align(4) = 0,

     

       15
       15
       +
           _reserved4: u16 = 0,

     

       16
       16
       +
           io_map_base_address: u16 = @sizeOf(Tss),

     

       17
       17
       +
       };

+40

components/ukernel/arch/riscv64/linker.ld

···

       1
       1
       +
       OUTPUT_FORMAT(elf64-littleriscv)

     

       2
       2
       +
       ENTRY(_start)

     

       3
       3
       +
       

     

       4
       4
       +
       PHDRS {

     

       5
       5
       +
           text    PT_LOAD;

     

       6
       6
       +
           rodata  PT_LOAD;

     

       7
       7
       +
           data    PT_LOAD;

     

       8
       8
       +
       }

     

       9
       9
       +
       

     

       10
       10
       +
       SECTIONS {

     

       11
       11
       +
           . = 0xffffffff80000000;

     

       12
       12
       +
       

     

       13
       13
       +
           .text : {

     

       14
       14
       +
               *(.text .text.*)

     

       15
       15
       +
           } :text

     

       16
       16
       +
       

     

       17
       17
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       18
       18
       +
       

     

       19
       19
       +
           .rodata : {

     

       20
       20
       +
               *(.rodata .rodata.*)

     

       21
       21
       +
           } :rodata

     

       22
       22
       +
       

     

       23
       23
       +
           . = ALIGN(CONSTANT(MAXPAGESIZE));

     

       24
       24
       +
       

     

       25
       25
       +
           .data : {

     

       26
       26
       +
               *(.data .data.*)

     

       27
       27
       +
               *(.sdata .sdata.*)

     

       28
       28
       +
           } :data

     

       29
       29
       +
       

     

       30
       30
       +
           .bss : {

     

       31
       31
       +
               *(.sbss .sbss.*)

     

       32
       32
       +
               *(.bss .bss.*)

     

       33
       33
       +
               *(COMMON)

     

       34
       34
       +
           } :data

     

       35
       35
       +
       

     

       36
       36
       +
           /DISCARD/ : {

     

       37
       37
       +
               *(.eh_frame*)

     

       38
       38
       +
               *(.note .note.*)

     

       39
       39
       +
           }

     

       40
       40
       +
       }

+97

components/ukernel/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const build_helpers = @import("build_helpers");

     

       3
       3
       +
       

     

       4
       4
       +
       pub fn build(b: *std.Build) void {

     

       5
       5
       +
           const arch = b.option(build_helpers.Architecture, "arch", "The target ukernel architecture") orelse .amd64;

     

       6
       6
       +
       

     

       7
       7
       +
           // set CPU features based on the architecture

     

       8
       8
       +
           var target_query: std.Target.Query = .{

     

       9
       9
       +
               .cpu_arch = arch.get(),

     

       10
       10
       +
               .os_tag = .freestanding,

     

       11
       11
       +
               .abi = .none,

     

       12
       12
       +
           };

     

       13
       13
       +
           const arch_root_path, const linker_script_path, const code_model: std.builtin.CodeModel = blk: {

     

       14
       14
       +
               switch (arch) {

     

       15
       15
       +
                   .amd64 => {

     

       16
       16
       +
                       const Feature = std.Target.x86.Feature;

     

       17
       17
       +
       

     

       18
       18
       +
                       target_query.cpu_features_add.addFeature(@intFromEnum(Feature.soft_float));

     

       19
       19
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.mmx));

     

       20
       20
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.sse));

     

       21
       21
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.sse2));

     

       22
       22
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.avx));

     

       23
       23
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.avx2));

     

       24
       24
       +
       

     

       25
       25
       +
                       break :blk .{ "arch/amd64/root.zig", "arch/amd64/linker.ld", .kernel };

     

       26
       26
       +
                   },

     

       27
       27
       +
                   .aarch64 => {

     

       28
       28
       +
                       const Feature = std.Target.aarch64.Feature;

     

       29
       29
       +
       

     

       30
       30
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.fp_armv8));

     

       31
       31
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.crypto));

     

       32
       32
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.neon));

     

       33
       33
       +
       

     

       34
       34
       +
                       break :blk .{ "arch/aarch64/root.zig", "arch/aarch64/linker.ld", .default };

     

       35
       35
       +
                   },

     

       36
       36
       +
                   .riscv64 => {

     

       37
       37
       +
                       const Feature = std.Target.riscv.Feature;

     

       38
       38
       +
                       target_query.cpu_features_sub.addFeature(@intFromEnum(Feature.d));

     

       39
       39
       +
       

     

       40
       40
       +
                       break :blk .{ "arch/riscv64/root.zig", "arch/riscv64/linker.ld", .default };

     

       41
       41
       +
                   },

     

       42
       42
       +
               }

     

       43
       43
       +
           };

     

       44
       44
       +
       

     

       45
       45
       +
           const target = b.resolveTargetQuery(target_query);

     

       46
       46
       +
           const optimize = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseSafe });

     

       47
       47
       +
       

     

       48
       48
       +
           const arch_module = b.createModule(.{

     

       49
       49
       +
               .root_source_file = b.path(arch_root_path),

     

       50
       50
       +
               .target = target,

     

       51
       51
       +
               .optimize = optimize,

     

       52
       52
       +
               .code_model = code_model,

     

       53
       53
       +
           });

     

       54
       54
       +
       

     

       55
       55
       +
           switch (arch) {

     

       56
       56
       +
               .amd64 => {

     

       57
       57
       +
                   arch_module.addAssemblyFile(b.path("arch/amd64/asm/traps.S"));

     

       58
       58
       +
               },

     

       59
       59
       +
               else => {},

     

       60
       60
       +
           }

     

       61
       61
       +
       

     

       62
       62
       +
           const limine_dep = b.dependency("limine", .{

     

       63
       63
       +
               .api_revision = 3,

     

       64
       64
       +
           });

     

       65
       65
       +
           const spinlock_dep = b.dependency("spinlock", .{});

     

       66
       66
       +
           const console_dep = b.dependency("console", .{});

     

       67
       67
       +
       

     

       68
       68
       +
           const limine_mod = limine_dep.module("limine");

     

       69
       69
       +
           const console_mod = console_dep.module("console");

     

       70
       70
       +
           const spinlock_mod = spinlock_dep.module("spinlock");

     

       71
       71
       +
       

     

       72
       72
       +
           const common_mod = b.createModule(.{

     

       73
       73
       +
               .root_source_file = b.path("common/root.zig"),

     

       74
       74
       +
           });

     

       75
       75
       +
       

     

       76
       76
       +
           arch_module.addImport("limine", limine_mod);

     

       77
       77
       +
           arch_module.addImport("console", console_mod);

     

       78
       78
       +
           arch_module.addImport("common", common_mod);

     

       79
       79
       +
       

     

       80
       80
       +
           console_mod.addImport("limine", limine_mod);

     

       81
       81
       +
       

     

       82
       82
       +
           common_mod.addImport("arch", arch_module);

     

       83
       83
       +
           common_mod.addImport("console", console_mod);

     

       84
       84
       +
           common_mod.addImport("spinlock", spinlock_mod);

     

       85
       85
       +
       

     

       86
       86
       +
           const kernel = b.addExecutable(.{

     

       87
       87
       +
               .name = "ukernel",

     

       88
       88
       +
               .root_module = arch_module,

     

       89
       89
       +
               // TODO: remove when x86 backend is less broken with removing CPU features

     

       90
       90
       +
               .use_llvm = true,

     

       91
       91
       +
           });

     

       92
       92
       +
       

     

       93
       93
       +
           kernel.pie = false;

     

       94
       94
       +
           kernel.want_lto = true;

     

       95
       95
       +
           kernel.setLinkerScript(b.path(linker_script_path));

     

       96
       96
       +
           b.installArtifact(kernel);

     

       97
       97
       +
       }

+18

components/ukernel/build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .ukernel,

     

       3
       3
       +
           .fingerprint = 0xcf2c1bfa85f3f299,

     

       4
       4
       +
           .version = "0.0.1",

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{

     

       7
       7
       +
               .limine = .{ .path = "deps/limine-zig" },

     

       8
       8
       +
               .spinlock = .{ .path = "deps/spinlock" },

     

       9
       9
       +
               .console = .{ .path = "deps/console" },

     

       10
       10
       +
               .build_helpers = .{ .path = "../build_helpers" },

     

       11
       11
       +
           },

     

       12
       12
       +
           .paths = .{

     

       13
       13
       +
               "build.zig",

     

       14
       14
       +
               "build.zig.zon",

     

       15
       15
       +
               "deps",

     

       16
       16
       +
               "arch",

     

       17
       17
       +
           },

     

       18
       18
       +
       }

+73

components/ukernel/common/aux.zig

···

       1
       1
       +
       const console = @import("console");

     

       2
       2
       +
       const common = @import("root.zig");

     

       3
       3
       +
       const mm = common.mm;

     

       4
       4
       +
       const std = @import("std");

     

       5
       5
       +
       const arch = @import("arch");

     

       6
       6
       +
       const spinlock = @import("spinlock");

     

       7
       7
       +
       

     

       8
       8
       +
       // Types

     

       9
       9
       +
       pub const HardwareDescription = union(enum) {

     

       10
       10
       +
           /// Physical address of ACPI RSDP

     

       11
       11
       +
           acpi_rsdp: usize,

     

       12
       12
       +
           /// Virtual pointer to DTB

     

       13
       13
       +
           dtb: *anyopaque,

     

       14
       14
       +
           none,

     

       15
       15
       +
       };

     

       16
       16
       +
       

     

       17
       17
       +
       pub const InitState = struct {

     

       18
       18
       +
           bootmem: mm.bootmem.BootPmm = .{},

     

       19
       19
       +
           console: ?console.Console = null,

     

       20
       20
       +
           framebuffer: ?console.Framebuffer = null,

     

       21
       21
       +
           hardware_description: HardwareDescription = .none,

     

       22
       22
       +
           root_task: []align(4096) u8 = undefined,

     

       23
       23
       +
           hhdm_slide: usize = 0,

     

       24
       24
       +
       };

     

       25
       25
       +
       

     

       26
       26
       +
       var stdout_lock: spinlock.Spinlock = .{};

     

       27
       27
       +
       

     

       28
       28
       +
       pub fn logFn(

     

       29
       29
       +
           comptime message_level: std.log.Level,

     

       30
       30
       +
           comptime scope: @TypeOf(.enum_literal),

     

       31
       31
       +
           comptime format: []const u8,

     

       32
       32
       +
           args: anytype,

     

       33
       33
       +
       ) void {

     

       34
       34
       +
           if (common.init_data.console == null) return;

     

       35
       35
       +
       

     

       36
       36
       +
           // Use the same naming as the default logger

     

       37
       37
       +
           const level, const color = switch (message_level) {

     

       38
       38
       +
               .debug => .{ "D", 0x3bcf1d },

     

       39
       39
       +
               .err => .{ "E", 0xff0000 },

     

       40
       40
       +
               .info => .{ "I", 0x00bbbb },

     

       41
       41
       +
               .warn => .{ "W", 0xfee409 },

     

       42
       42
       +
           };

     

       43
       43
       +
           // Use same format as default once again

     

       44
       44
       +
           const scope_text = switch (scope) {

     

       45
       45
       +
               .default => "",

     

       46
       46
       +
               else => "<" ++ @tagName(scope) ++ ">",

     

       47
       47
       +
           };

     

       48
       48
       +
           const prefix = std.fmt.comptimePrint("{s}{s}: ", .{ level, scope_text });

     

       49
       49
       +
       

     

       50
       50
       +
           {

     

       51
       51
       +
               stdout_lock.lock();

     

       52
       52
       +
               defer stdout_lock.unlock();

     

       53
       53
       +
       

     

       54
       54
       +
               const cons = &common.init_data.console.?;

     

       55
       55
       +
       

     

       56
       56
       +
               cons.setColor(color, 0);

     

       57
       57
       +
               cons.writer().print(prefix ++ format ++ "\n", args) catch return;

     

       58
       58
       +
           }

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       pub fn panic(msg: []const u8, first_trace_addr: ?usize) noreturn {

     

       62
       62
       +
           _ = first_trace_addr;

     

       63
       63
       +
           const log = std.log.scoped(.panic);

     

       64
       64
       +
           common.init_data.console.?.setColor(0xff0000, 0);

     

       65
       65
       +
           log.err("PANIC: {s}", .{msg});

     

       66
       66
       +
           var it = std.debug.StackIterator.init(@returnAddress(), @frameAddress());

     

       67
       67
       +
           defer it.deinit();

     

       68
       68
       +
           while (it.next()) |addr| {

     

       69
       69
       +
               if (addr == 0) break;

     

       70
       70
       +
               log.err("Addr: 0x{x:0>16}", .{addr});

     

       71
       71
       +
           }

     

       72
       72
       +
           arch.instructions.die();

     

       73
       73
       +
       }

+146

components/ukernel/common/mm/bootmem.zig

···

       1
       1
       +
       /// Simple Multi Bump Allocator, because the old buddy system wasn't

     

       2
       2
       +
       /// suitable to pass memory down to the root task, and we never

     

       3
       3
       +
       /// have to free memory

     

       4
       4
       +
       const std = @import("std");

     

       5
       5
       +
       const common = @import("../root.zig");

     

       6
       6
       +
       const arch = @import("arch");

     

       7
       7
       +
       const log = std.log.scoped(.bootmem);

     

       8
       8
       +
       

     

       9
       9
       +
       /// This is meant for pageframe allocation, does bump allocation with

     

       10
       10
       +
       /// a first fit from the end. Ideally we do as little memory allocation

     

       11
       11
       +
       /// as possible in the microkernel anyways.

     

       12
       12
       +
       pub const BootPmm = struct {

     

       13
       13
       +
           // Store this in a chunk of ram which you remove from the region

     

       14
       14
       +
           regions: []Region = undefined,

     

       15
       15
       +
           //top_region: usize = undefined,

     

       16
       16
       +
       

     

       17
       17
       +
           const Self = @This();

     

       18
       18
       +
           pub const Region = struct {

     

       19
       19
       +
               base: usize,

     

       20
       20
       +
               length: usize,

     

       21
       21
       +
               type: RegionType,

     

       22
       22
       +
           };

     

       23
       23
       +
           pub const RegionType = enum(usize) {

     

       24
       24
       +
               usable = 0,

     

       25
       25
       +
               acpi_reclaimable = 1,

     

       26
       26
       +
               bootloader_reclaimable = 2,

     

       27
       27
       +
               executable_and_modules = 3,

     

       28
       28
       +
               framebuffer = 4,

     

       29
       29
       +
               // Just forget about reserved regions for now

     

       30
       30
       +
               reserved = 5,

     

       31
       31
       +
           };

     

       32
       32
       +
       

     

       33
       33
       +
           // Calculate the needed size to allocate the []Region slice

     

       34
       34
       +
           pub fn calculateMetadataSize(entries: usize) usize {

     

       35
       35
       +
               return entries * @sizeOf(Region);

     

       36
       36
       +
           }

     

       37
       37
       +
       

     

       38
       38
       +
           /// For the love of god len(regions) must be > 0

     

       39
       39
       +
           /// Only call this function once

     

       40
       40
       +
           pub fn initialize(self: *Self, regions: []Region) void {

     

       41
       41
       +
               self.regions = regions;

     

       42
       42
       +
               //self.top_region = regions.len - 1;

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
           /// Allocates physical memory, aligned to page size

     

       46
       46
       +
           pub fn allocPhys(self: *Self, size: usize) !usize {

     

       47
       47
       +
               if (self.regions.len == 0) {

     

       48
       48
       +
                   @branchHint(.cold);

     

       49
       49
       +
                   return error.NoMemory;

     

       50
       50
       +
               }

     

       51
       51
       +
               const true_alloc_size = std.mem.alignForward(usize, size, std.heap.pageSize());

     

       52
       52
       +
       

     

       53
       53
       +
               var i: usize = self.regions.len;

     

       54
       54
       +
               while (i > 0) : (i -= 1) {

     

       55
       55
       +
                   const region = &self.regions[i - 1];

     

       56
       56
       +
                   if (region.type != .usable) continue;

     

       57
       57
       +
                   if (true_alloc_size > region.length) continue;

     

       58
       58
       +
                   region.length -= true_alloc_size;

     

       59
       59
       +
                   return region.base + region.length;

     

       60
       60
       +
               }

     

       61
       61
       +
               return error.OutOfMemory;

     

       62
       62
       +
           }

     

       63
       63
       +
       

     

       64
       64
       +
           pub fn allocMem(self: *Self, size: usize) !usize {

     

       65
       65
       +
               return try self.allocPhys(size) + common.init_data.hhdm_slide;

     

       66
       66
       +
           }

     

       67
       67
       +
       

     

       68
       68
       +
           pub fn debugInfo(self: *Self) void {

     

       69
       69
       +
               var total: usize = 0;

     

       70
       70
       +
               var usable: usize = 0;

     

       71
       71
       +
       

     

       72
       72
       +
               for (self.regions) |region| {

     

       73
       73
       +
                   total += region.length;

     

       74
       74
       +
                   if (region.type == .usable) usable += region.length;

     

       75
       75
       +
               }

     

       76
       76
       +
       

     

       77
       77
       +
               const total_gib = total / (1 << 30);

     

       78
       78
       +
               total -= total_gib * (1 << 30);

     

       79
       79
       +
               const total_mib = total / (1 << 20);

     

       80
       80
       +
               total -= total_mib * (1 << 20);

     

       81
       81
       +
               const total_kib = total / (1 << 10);

     

       82
       82
       +
               log.debug("Total Memory: {} GiB + {} MiB + {} KiB", .{ total_gib, total_mib, total_kib });

     

       83
       83
       +
       

     

       84
       84
       +
               const usable_gib = usable / (1 << 30);

     

       85
       85
       +
               usable -= usable_gib * (1 << 30);

     

       86
       86
       +
               const usable_mib = usable / (1 << 20);

     

       87
       87
       +
               usable -= usable_mib * (1 << 20);

     

       88
       88
       +
               const usable_kib = usable / (1 << 10);

     

       89
       89
       +
               log.debug("Usable: {} GiB + {} MiB + {} KiB", .{ usable_gib, usable_mib, usable_kib });

     

       90
       90
       +
           }

     

       91
       91
       +
       };

     

       92
       92
       +
       

     

       93
       93
       +
       pub fn init() void {

     

       94
       94
       +
           const memmap = arch.boot.limine_requests.memmap.response.?.getEntries();

     

       95
       95
       +
       

     

       96
       96
       +
           const bootmem_structure_size, const region_count = blk: {

     

       97
       97
       +
               var region_count: usize = 0;

     

       98
       98
       +
               for (memmap) |region| {

     

       99
       99
       +
                   switch (region.type) {

     

       100
       100
       +
                       .usable, .acpi_reclaimable, .bootloader_reclaimable, .executable_and_modules, .framebuffer => region_count += 1,

     

       101
       101
       +
                       else => {},

     

       102
       102
       +
                   }

     

       103
       103
       +
               }

     

       104
       104
       +
       

     

       105
       105
       +
               break :blk .{ BootPmm.calculateMetadataSize(region_count), region_count };

     

       106
       106
       +
           };

     

       107
       107
       +
           const bootmem_pages = std.mem.alignForward(usize, bootmem_structure_size, std.heap.pageSize());

     

       108
       108
       +
       

     

       109
       109
       +
           // Given the bootmem structure size, find a page to hold it

     

       110
       110
       +
           const bootmem_struct: []BootPmm.Region = blk: {

     

       111
       111
       +
               var i: usize = memmap.len;

     

       112
       112
       +
               while (i > 0) : (i -= 1) {

     

       113
       113
       +
                   const region = memmap[i - 1];

     

       114
       114
       +
                   if (bootmem_pages > region.length) continue;

     

       115
       115
       +
                   switch (region.type) {

     

       116
       116
       +
                       .usable => {},

     

       117
       117
       +
                       else => continue,

     

       118
       118
       +
                   }

     

       119
       119
       +
                   // Unfortunately, we can't modify the limine memory map itself

     

       120
       120
       +
                   // So, remember the region we ate from instead

     

       121
       121
       +
                   region.length -= bootmem_pages;

     

       122
       122
       +
                   const bootmem_struct_ptr = common.mm.physToHHDM([*]BootPmm.Region, region.base + region.length);

     

       123
       123
       +
                   break :blk bootmem_struct_ptr[0..region_count];

     

       124
       124
       +
               }

     

       125
       125
       +
               @panic("Couldn't allocate bootmem structure!");

     

       126
       126
       +
           };

     

       127
       127
       +
           // Now, fill the bootmem structure out from the limine memmap

     

       128
       128
       +
           var i: usize = 0;

     

       129
       129
       +
           for (memmap) |region| {

     

       130
       130
       +
               switch (region.type) {

     

       131
       131
       +
                   .usable => bootmem_struct[i].type = .usable,

     

       132
       132
       +
                   .acpi_reclaimable => bootmem_struct[i].type = .acpi_reclaimable,

     

       133
       133
       +
                   .bootloader_reclaimable => bootmem_struct[i].type = .bootloader_reclaimable,

     

       134
       134
       +
                   .executable_and_modules => bootmem_struct[i].type = .executable_and_modules,

     

       135
       135
       +
                   .framebuffer => bootmem_struct[i].type = .framebuffer,

     

       136
       136
       +
                   else => continue,

     

       137
       137
       +
               }

     

       138
       138
       +
               bootmem_struct[i].base = region.base;

     

       139
       139
       +
               bootmem_struct[i].length = region.length;

     

       140
       140
       +
               i += 1;

     

       141
       141
       +
           }

     

       142
       142
       +
       

     

       143
       143
       +
           // Finally, initialize the global bootmem

     

       144
       144
       +
           common.init_data.bootmem.initialize(bootmem_struct);

     

       145
       145
       +
           common.init_data.bootmem.debugInfo();

     

       146
       146
       +
       }

+117

components/ukernel/common/mm/paging.zig

···

       1
       1
       +
       const arch = @import("arch");

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const TableHandle = arch.mm.paging.TableHandle;

     

       4
       4
       +
       const MemoryType = arch.mm.paging.MemoryType;

     

       5
       5
       +
       

     

       6
       6
       +
       pub const Perms = struct {

     

       7
       7
       +
           writable: bool,

     

       8
       8
       +
           executable: bool,

     

       9
       9
       +
           userspace_accessible: bool = false,

     

       10
       10
       +
       

     

       11
       11
       +
           const Self = @This();

     

       12
       12
       +
       

     

       13
       13
       +
           /// Verify that the current permissions are a superset of the provided ones

     

       14
       14
       +
           pub fn allows(self: Self, other: Self) bool {

     

       15
       15
       +
               if (!self.writable and other.writable) {

     

       16
       16
       +
                   return false;

     

       17
       17
       +
               }

     

       18
       18
       +
               if (!self.executable and other.executable) {

     

       19
       19
       +
                   return false;

     

       20
       20
       +
               }

     

       21
       21
       +
               if (!self.userspace_accessible and other.userspace_accessible) {

     

       22
       22
       +
                   return false;

     

       23
       23
       +
               }

     

       24
       24
       +
               return true;

     

       25
       25
       +
           }

     

       26
       26
       +
       

     

       27
       27
       +
           /// OR two permissions

     

       28
       28
       +
           pub fn addPerms(self: Self, other: Self) Self {

     

       29
       29
       +
               return .{

     

       30
       30
       +
                   .writable = self.writable or other.writable,

     

       31
       31
       +
                   .executable = self.executable or other.executable,

     

       32
       32
       +
                   .userspace = self.userspace_accessible or other.userspace_accessible,

     

       33
       33
       +
               };

     

       34
       34
       +
           }

     

       35
       35
       +
       };

     

       36
       36
       +
       

     

       37
       37
       +
       pub const PTEType = enum { Mapping, Table, Empty };

     

       38
       38
       +
       

     

       39
       39
       +
       pub fn mapPhys(args: struct {

     

       40
       40
       +
           vaddr: usize,

     

       41
       41
       +
           paddr: usize,

     

       42
       42
       +
           size: usize,

     

       43
       43
       +
           perms: Perms,

     

       44
       44
       +
           memory_type: MemoryType,

     

       45
       45
       +
       }) !void {

     

       46
       46
       +
           const root = arch.mm.paging.root_table(args.vaddr);

     

       47
       47
       +
           var vaddr = args.vaddr;

     

       48
       48
       +
           var paddr = args.paddr;

     

       49
       49
       +
           var size = args.size;

     

       50
       50
       +
           try mapPageImpl(&vaddr, &paddr, &size, root, args.perms, args.memory_type);

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       fn mapPageImpl(

     

       54
       54
       +
           vaddr: *usize,

     

       55
       55
       +
           paddr: ?*usize,

     

       56
       56
       +
           size: *usize,

     

       57
       57
       +
           table: TableHandle,

     

       58
       58
       +
           perms: Perms,

     

       59
       59
       +
           memory_type: MemoryType,

     

       60
       60
       +
       ) !void {

     

       61
       61
       +
           // 1. Get slice of every child from the target forwards

     

       62
       62
       +
           const children = table.skip_to(vaddr.*);

     

       63
       63
       +
       

     

       64
       64
       +
           // 2. For each PTE, decode to the type (Mapping, Table, Empty)

     

       65
       65
       +
           // If there's already a mapping, we're fucked

     

       66
       66
       +
           // If it's a table, keep going forward till we reach Mapping or Empty,

     

       67
       67
       +
           // while of course ensuring permissions

     

       68
       68
       +
           // If it's empty, check if we reached our target level. If we didn't,

     

       69
       69
       +
           // then make a new child table and keep going. If it's not empty, then

     

       70
       70
       +
           // make the child mapping and reduce the amount of size we're targetting

     

       71
       71
       +
           for (children) |*child| {

     

       72
       72
       +
               switch (table.decode_child(child)) {

     

       73
       73
       +
                   .Mapping => return error.AlreadyPresent,

     

       74
       74
       +
                   .Table => |*tbl| {

     

       75
       75
       +
                       try mapPageImpl(vaddr, paddr, size, tbl.*, perms, memory_type);

     

       76
       76
       +
                       if (!tbl.perms.allows(perms)) {

     

       77
       77
       +
                           tbl.addPerms(perms);

     

       78
       78
       +
                           arch.mm.paging.invalidate(vaddr.*);

     

       79
       79
       +
                       }

     

       80
       80
       +
                   },

     

       81
       81
       +
                   .Empty => {

     

       82
       82
       +
                       const domain = table.child_domain(vaddr.*);

     

       83
       83
       +
                       if (domain.ptr == vaddr.* and domain.len <= size.* and arch.mm.paging.can_map_at(table.level - 1) and is_aligned(vaddr.*, paddr, table.level - 1)) {

     

       84
       84
       +
                           // Make child mapping etc

     

       85
       85
       +
                           _ = try table.make_child_mapping(child, if (paddr) |p| p.* else null, perms, memory_type);

     

       86
       86
       +
                           const step = domain.len;

     

       87
       87
       +
                           if (step >= size.*) {

     

       88
       88
       +
                               size.* = 0;

     

       89
       89
       +
                               return;

     

       90
       90
       +
                           } else {

     

       91
       91
       +
                               size.* -= step;

     

       92
       92
       +
                               vaddr.* += step;

     

       93
       93
       +
                               if (paddr) |p| {

     

       94
       94
       +
                                   p.* += step;

     

       95
       95
       +
                               }

     

       96
       96
       +
                           }

     

       97
       97
       +
                       } else {

     

       98
       98
       +
                           const tbl = try table.make_child_table(child, perms);

     

       99
       99
       +
                           try mapPageImpl(vaddr, paddr, size, tbl, perms, memory_type);

     

       100
       100
       +
                       }

     

       101
       101
       +
                   },

     

       102
       102
       +
               }

     

       103
       103
       +
               if (size.* == 0) return;

     

       104
       104
       +
           }

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       fn is_aligned(vaddr: usize, paddr: ?*usize, level: u3) bool {

     

       108
       108
       +
           if (!std.mem.isAligned(vaddr, arch.mm.paging.page_sizes[level])) {

     

       109
       109
       +
               return false;

     

       110
       110
       +
           }

     

       111
       111
       +
       

     

       112
       112
       +
           if (paddr) |p| {

     

       113
       113
       +
               return std.mem.isAligned(p.*, arch.mm.paging.page_sizes[level]);

     

       114
       114
       +
           }

     

       115
       115
       +
       

     

       116
       116
       +
           return true;

     

       117
       117
       +
       }

components/ukernel/common/mm/root.zig

···

       1
       1
       +
       pub const bootmem = @import("bootmem.zig");

     

       2
       2
       +
       pub const common = @import("../root.zig");

     

       3
       3
       +
       pub const paging = @import("paging.zig");

     

       4
       4
       +
       

     

       5
       5
       +
       pub fn physToHHDM(comptime T: type, phys_addr: u64) T {

     

       6
       6
       +
           return @ptrFromInt(common.init_data.hhdm_slide + phys_addr);

     

       7
       7
       +
       }

components/ukernel/common/root.zig

···

       1
       1
       +
       pub const aux = @import("aux.zig");

     

       2
       2
       +
       pub const mm = @import("mm/root.zig");

     

       3
       3
       +
       

     

       4
       4
       +
       // Arch init must set up appropriate fields!

     

       5
       5
       +
       pub var init_data: aux.InitState = .{};

components/ukernel/deps/console/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn build(b: *std.Build) void {

     

       4
       4
       +
           _ = b.addModule("console", .{

     

       5
       5
       +
               .root_source_file = b.path("console.zig"),

     

       6
       6
       +
           });

     

       7
       7
       +
       }

+18

components/ukernel/deps/console/build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .console,

     

       3
       3
       +
           .fingerprint = 0x3603cfb6f7920fba,

     

       4
       4
       +
           .version = "0.0.1",

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{

     

       7
       7
       +
               .limine = .{

     

       8
       8
       +
                   .path = "../limine-zig",

     

       9
       9
       +
               },

     

       10
       10
       +
           },

     

       11
       11
       +
           .paths = .{

     

       12
       12
       +
               "build.zig",

     

       13
       13
       +
               "build.zig.zon",

     

       14
       14
       +
               "console.zig",

     

       15
       15
       +
               "psf2.zig",

     

       16
       16
       +
               "fonts",

     

       17
       17
       +
           },

     

       18
       18
       +
       }

+195

components/ukernel/deps/console/console.zig

···

       1
       1
       +
       const limine = @import("limine");

     

       2
       2
       +
       const builtin = @import("builtin");

     

       3
       3
       +
       const psf2 = @import("psf2.zig");

     

       4
       4
       +
       pub const Font = psf2.Font;

     

       5
       5
       +
       const std = @import("std");

     

       6
       6
       +
       const fontdata = @embedFile("fonts/spleen-12x24.psf");

     

       7
       7
       +
       const are_we_le = builtin.cpu.arch.endian() == .little;

     

       8
       8
       +
       

     

       9
       9
       +
       pub const DefaultFont = Font.new(fontdata) catch unreachable;

     

       10
       10
       +
       

     

       11
       11
       +
       pub const Framebuffer = struct {

     

       12
       12
       +
           const Self = @This();

     

       13
       13
       +
           address: [*]u8,

     

       14
       14
       +
           width: u64,

     

       15
       15
       +
           height: u64,

     

       16
       16
       +
           pitch: u64,

     

       17
       17
       +
           bypp: u16,

     

       18
       18
       +
           red_mask_size: u8,

     

       19
       19
       +
           red_mask_shift: u8,

     

       20
       20
       +
           green_mask_size: u8,

     

       21
       21
       +
           green_mask_shift: u8,

     

       22
       22
       +
           blue_mask_size: u8,

     

       23
       23
       +
           blue_mask_shift: u8,

     

       24
       24
       +
       

     

       25
       25
       +
           pub fn from_limine(fb: *const limine.Framebuffer) Self {

     

       26
       26
       +
               return .{

     

       27
       27
       +
                   .address = @ptrCast(fb.address),

     

       28
       28
       +
                   .width = fb.width,

     

       29
       29
       +
                   .height = fb.height,

     

       30
       30
       +
                   .pitch = fb.pitch,

     

       31
       31
       +
                   .red_mask_size = fb.red_mask_size,

     

       32
       32
       +
                   .red_mask_shift = fb.red_mask_shift,

     

       33
       33
       +
                   .green_mask_size = fb.green_mask_size,

     

       34
       34
       +
                   .green_mask_shift = fb.green_mask_shift,

     

       35
       35
       +
                   .blue_mask_size = fb.blue_mask_size,

     

       36
       36
       +
                   .blue_mask_shift = fb.blue_mask_shift,

     

       37
       37
       +
                   .bypp = fb.bpp / 8,

     

       38
       38
       +
               };

     

       39
       39
       +
           }

     

       40
       40
       +
       };

     

       41
       41
       +
       

     

       42
       42
       +
       pub const Console = struct {

     

       43
       43
       +
           const Self = @This();

     

       44
       44
       +
           const Writer = std.io.GenericWriter(*Self, error{}, write);

     

       45
       45
       +
           // framebuffer data

     

       46
       46
       +
           fb: Framebuffer,

     

       47
       47
       +
           // font

     

       48
       48
       +
           font: psf2.Font,

     

       49
       49
       +
           // state data

     

       50
       50
       +
           current_x: u64 = 0,

     

       51
       51
       +
           current_y: u64 = 0,

     

       52
       52
       +
           fg_color: u32 = 0xFFFFFFFF,

     

       53
       53
       +
           bg_color: u32 = 0,

     

       54
       54
       +
       

     

       55
       55
       +
           pub fn from_font(fb: Framebuffer, font: psf2.Font) Self {

     

       56
       56
       +
               return .{

     

       57
       57
       +
                   .fb = fb,

     

       58
       58
       +
                   .font = font,

     

       59
       59
       +
               };

     

       60
       60
       +
           }

     

       61
       61
       +
       

     

       62
       62
       +
           // places a character at the given position

     

       63
       63
       +
           pub fn putchar(self: *const Self, ch: u8, cx: u64, cy: u64, fg_val: u32, bg_val: u32) void {

     

       64
       64
       +
               // convert colors to bytes

     

       65
       65
       +
               const fg_bytes: [4]u8 = @bitCast(if (are_we_le) fg_val else @byteSwap(fg_val));

     

       66
       66
       +
               const bg_bytes: [4]u8 = @bitCast(if (are_we_le) bg_val else @byteSwap(bg_val));

     

       67
       67
       +
               // initial calculations

     

       68
       68
       +
               const bytes_per_line = self.font.hdr.bytesPerLine();

     

       69
       69
       +
               const mask_shamt: u5 = @intCast(bytes_per_line * 8 - 1);

     

       70
       70
       +
               const mask_initial: u32 = @as(u32, 1) << mask_shamt;

     

       71
       71
       +
               const glyph = self.font.getGlyph(ch) catch return;

     

       72
       72
       +
       

     

       73
       73
       +
               // find the screen offset for the beignning of the character

     

       74
       74
       +
               // add pitch to go to next line...

     

       75
       75
       +
               var offset: u64 = (cy * self.font.hdr.height * self.fb.pitch) + (cx * (self.font.hdr.width + 0) * self.fb.bypp);

     

       76
       76
       +
               // run for every line

     

       77
       77
       +
               var y: u32 = 0;

     

       78
       78
       +
               var mask: u32 = 0;

     

       79
       79
       +
               while (y < self.font.hdr.height) : (y += 1) {

     

       80
       80
       +
                   // initialize the mask and the current line

     

       81
       81
       +
                   mask = mask_initial;

     

       82
       82
       +
       

     

       83
       83
       +
                   // get the current line

     

       84
       84
       +
                   const line_value: u32 = psf2.readIntTo32(glyph[y * bytes_per_line ..][0..bytes_per_line]);

     

       85
       85
       +
                   var line_offset: u64 = offset;

     

       86
       86
       +
                   var x: u32 = 0;

     

       87
       87
       +
                   while (x < self.font.hdr.width) : (x += 1) {

     

       88
       88
       +
                       // write the pixel value to the correct position of the screen...

     

       89
       89
       +
                       if (line_value & mask != 0) {

     

       90
       90
       +
                           @memcpy(self.fb.address[line_offset..][0..self.fb.bypp], fg_bytes[0..]);

     

       91
       91
       +
                       } else {

     

       92
       92
       +
                           @memcpy(self.fb.address[line_offset..][0..self.fb.bypp], bg_bytes[0..]);

     

       93
       93
       +
                       }

     

       94
       94
       +
                       line_offset += self.fb.bypp;

     

       95
       95
       +
                       mask >>= 1;

     

       96
       96
       +
                   }

     

       97
       97
       +
                   offset += self.fb.pitch;

     

       98
       98
       +
               }

     

       99
       99
       +
           }

     

       100
       100
       +
       

     

       101
       101
       +
           pub fn putc(self: *Self, ch: u8) void {

     

       102
       102
       +
               // input can be \r, \n, or printable.

     

       103
       103
       +
               // ignore \r, move down for \n, and print char normally

     

       104
       104
       +
               // if \n, check to see if we overrun then scroll

     

       105
       105
       +
               // if normal, see if we overrun the end and do newline

     

       106
       106
       +
               if (ch == '\r') return;

     

       107
       107
       +
               if (ch == '\n') {

     

       108
       108
       +
                   self.current_x = 0;

     

       109
       109
       +
                   self.current_y += 1;

     

       110
       110
       +
                   // go to top if we went below the bottom of the screen

     

       111
       111
       +
                   if (self.current_y >= self.maxCharsHeight()) {

     

       112
       112
       +
                       self.scrollUp(1);

     

       113
       113
       +
                       self.current_y = self.maxCharsHeight() - 1;

     

       114
       114
       +
                   }

     

       115
       115
       +
                   return;

     

       116
       116
       +
               }

     

       117
       117
       +
               self.putchar(ch, self.current_x, self.current_y, self.fg_color, self.bg_color);

     

       118
       118
       +
               self.current_x += 1;

     

       119
       119
       +
       

     

       120
       120
       +
               if (self.current_x < self.maxCharsWidth()) return;

     

       121
       121
       +
               self.current_x = 0;

     

       122
       122
       +
               self.current_y += 1;

     

       123
       123
       +
               if (self.current_y >= self.maxCharsHeight()) {

     

       124
       124
       +
                   self.scrollUp(1);

     

       125
       125
       +
                   self.current_y = self.maxCharsHeight() - 1;

     

       126
       126
       +
               }

     

       127
       127
       +
           }

     

       128
       128
       +
       

     

       129
       129
       +
           pub fn puts(self: *Self, msg: []const u8) void {

     

       130
       130
       +
               for (msg) |ch| {

     

       131
       131
       +
                   self.putc(ch);

     

       132
       132
       +
               }

     

       133
       133
       +
           }

     

       134
       134
       +
       

     

       135
       135
       +
           fn convertColor(self: *const Self, color: u32) u32 {

     

       136
       136
       +
               const mult: u32 = blk: {

     

       137
       137
       +
                   const width: u4 = @truncate(self.fb.red_mask_size);

     

       138
       138
       +
                   break :blk (@as(u32, 1) << width) - 1;

     

       139
       139
       +
               };

     

       140
       140
       +
               const div = 255;

     

       141
       141
       +
               const red: u32 = (color >> 16) & 0xFF;

     

       142
       142
       +
               const green: u32 = (color >> 8) & 0xFF;

     

       143
       143
       +
               const blue: u32 = color & 0xFF;

     

       144
       144
       +
       

     

       145
       145
       +
               const red_shift: u5 = @truncate(self.fb.red_mask_shift);

     

       146
       146
       +
               const green_shift: u5 = @truncate(self.fb.green_mask_shift);

     

       147
       147
       +
               const blue_shift: u5 = @truncate(self.fb.blue_mask_shift);

     

       148
       148
       +
       

     

       149
       149
       +
               return (((red * mult) / div) << red_shift) | (((green * mult) / div) << green_shift) | (((blue * mult) / div) << blue_shift);

     

       150
       150
       +
           }

     

       151
       151
       +
       

     

       152
       152
       +
           pub fn setColor(self: *Self, fg: u32, bg: u32) void {

     

       153
       153
       +
               self.fg_color = self.convertColor(fg);

     

       154
       154
       +
               self.bg_color = self.convertColor(bg);

     

       155
       155
       +
           }

     

       156
       156
       +
       

     

       157
       157
       +
           pub fn writer(self: *Self) Writer {

     

       158
       158
       +
               return .{ .context = self };

     

       159
       159
       +
           }

     

       160
       160
       +
       

     

       161
       161
       +
           pub fn write(self: *Self, buffer: []const u8) !usize {

     

       162
       162
       +
               self.puts(buffer);

     

       163
       163
       +
               return buffer.len;

     

       164
       164
       +
           }

     

       165
       165
       +
       

     

       166
       166
       +
           // scroll the lines of text, without doing anything else.

     

       167
       167
       +
           // erase the first line of text, and memcpy the second line and on up to the first

     

       168
       168
       +
           pub fn scrollUp(self: *Self, amount: u64) void {

     

       169
       169
       +
               const num_lines = self.maxCharsHeight();

     

       170
       170
       +
               const h = self.font.hdr.height;

     

       171
       171
       +
               if (amount > num_lines) return; // later just clear the entire screen

     

       172
       172
       +
               var i: u64 = amount;

     

       173
       173
       +
               while (i < num_lines) : (i += 1) {

     

       174
       174
       +
                   // for each run, erase the previous line and copy the current line up a line.

     

       175
       175
       +
                   // const curr_line = self.fb.address[i * h * self.fb.pitch .. (i + 1) * h * self.fb.pitch];

     

       176
       176
       +
                   const curr_line = self.fb.address[i * h * self.fb.pitch ..][0 .. h * self.fb.pitch];

     

       177
       177
       +
                   const prev_line = self.fb.address[(i - amount) * h * self.fb.pitch ..][0 .. h * self.fb.pitch];

     

       178
       178
       +
       

     

       179
       179
       +
                   @memset(prev_line, 0);

     

       180
       180
       +
                   @memcpy(prev_line, curr_line);

     

       181
       181
       +
               }

     

       182
       182
       +
               // finally, delete the last line (s)

     

       183
       183
       +
               // const last_line = self.fb.address[(num_lines - amount) * h * self.fb.pitch .. (num_lines) * h * self.fb.pitch];

     

       184
       184
       +
               const last_line = self.fb.address[(num_lines - amount) * h * self.fb.pitch ..][0 .. amount * h * self.fb.pitch];

     

       185
       185
       +
               @memset(last_line, 0);

     

       186
       186
       +
           }

     

       187
       187
       +
       

     

       188
       188
       +
           fn maxCharsWidth(self: *const Self) u64 {

     

       189
       189
       +
               return self.fb.width / (self.font.hdr.width + 0);

     

       190
       190
       +
           }

     

       191
       191
       +
       

     

       192
       192
       +
           fn maxCharsHeight(self: *const Self) u64 {

     

       193
       193
       +
               return self.fb.height / self.font.hdr.height;

     

       194
       194
       +
           }

     

       195
       195
       +
       };

+24

components/ukernel/deps/console/fonts/LICENSE.spleen

···

       1
       1
       +
       Copyright (c) 2018-2024, Frederic Cambus

     

       2
       2
       +
       All rights reserved.

     

       3
       3
       +
       

     

       4
       4
       +
       Redistribution and use in source and binary forms, with or without

     

       5
       5
       +
       modification, are permitted provided that the following conditions are met:

     

       6
       6
       +
       

     

       7
       7
       +
         * Redistributions of source code must retain the above copyright

     

       8
       8
       +
           notice, this list of conditions and the following disclaimer.

     

       9
       9
       +
       

     

       10
       10
       +
         * Redistributions in binary form must reproduce the above copyright

     

       11
       11
       +
           notice, this list of conditions and the following disclaimer in the

     

       12
       12
       +
           documentation and/or other materials provided with the distribution.

     

       13
       13
       +
       

     

       14
       14
       +
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       15
       15
       +
       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       16
       16
       +
       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       17
       17
       +
       ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS

     

       18
       18
       +
       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       19
       19
       +
       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       20
       20
       +
       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       21
       21
       +
       INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       22
       22
       +
       CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       23
       23
       +
       ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       24
       24
       +
       POSSIBILITY OF SUCH DAMAGE.

components/ukernel/deps/console/fonts/bold16x32.psf