Previously, the buttons would be cropped (by the border thickness) as
the border is not shown on maximized windows. This patch adjusts the
button positions to correct for that.
These mounts are the base set of mounts we need for a fully functional
system. The bind mounts are also there for protection from malicious
software or accidental overwrite/deletion of files.
Therefore, marking these mounts as immutable makes sense, because they
should not be changed during runtime anyway.
Immutable mounts are mounts that can't be changed in any aspect, if the
VFSRootContext that hold them is used by a process. This includes two
operations on a mount:
1. Trying to remove the mount from the mount table.
2. Trying to change the flags of the mount.
The condition of a VFSRootContext being held by a process or not is
crucial, as the intention is to allow removal of mounts that marked as
immutable if the VFSRootContext is not being used anymore (for example,
if the container that was created with such context stopped).
Marking mounts as immutable on the first VFS root context essentially
ensures they will never be modified because there will be a process
using that context (which is the "main" VFS root context in the system
runtime).
It should be noted that setting a mount as immutable can be done in
creation time of the mount by passing the MS_IMMUTABLE flag, or by doing
a remount with MS_IMMUTABLE flag.
This adds a window theme that aims to imitate the default Windows 7
theme (known as Aero). This initial version mainly focuses on window
frames along with minor taskbar theming.
Currently, the colors for the window frames are hardcoded, but the
actual gradient painting uses the LibGfx gradient support, so it should
be fairly easy to make configurable.
This adds a window theme that aims to imitate the default Windows XP
theme (known as Luna). This initial version mainly focuses on window
frames along with minor taskbar theming.
Currently, the colors for the window frames are hardcoded, but the
actual gradient painting uses the LibGfx gradient support, so it should
be fairly easy to make configurable.
Choosing options from the `<select>` will load and display that style
sheet's source text, with some checks to make sure that the text that
just loaded is the one we currently want.
The UI is a little goofy when scrolling, as it uses `position: sticky`
which we don't implement yet. But that's just more motivation to
implement it! :^)
(cherry picked from commit da171c3230caaee53213d0dd04007c9b4343e3e2)
This wasn't visible, until I tried adding a top toolbar to a tab area,
which made it look silly.
(cherry picked from commit ced7b6de5e7b6fbe2b2739158d0116339901b4c3)
This adds the following behavior for the DOM node/attribute editor in
the Inspector:
* If the user double clicks on an attribute name, the name is selected.
* If the user double clicks on an attribute value, the value text (sans
the surrounding quotes) is selected.
* Otherwise, double clicks select the entire text range.
(cherry picked from commit 7fff00972d667e7c83ed0336dc8e7f8ddbd91298)
- Expose table from console object
- Add new Table log level
- Create a JS object that represents table rows and columns
- Print table as HTML using WebContentConsoleClient
(cherry picked from commit 785180dd45ef6dcce4d847e564eca52ed0ad955b)
When working on the Inspector's HTML, it's often kind of tricky to debug
when an element is styled / positioned incorrectly. We don't have a way
to inspect the Inspector itself.
This adds a button to the Inspector to export its HTML/CSS/JS contents
to the downloads directory. This allows for more easily testing changes,
especially by opening the exported HTML in another browser's dev tools.
We will ultimately likely remove this button (or make it hidden) by the
time we are production-ready. But it's quite useful for now.
(cherry picked from commit 3ec5c1941f25041c6bf073f2940f6035e084a4e2)
After the refactor to use CSS variables for dark-mode colors in commit
ae25146b898ce8900d04c4911f1f0835681aac4e, we had duplicated blocks for
some CSS rules. This patch just unites them into one block.
(cherry picked from commit cde7c91c54574a97ec73a441669cd6dfd07e6f8f)
This adds another tab to the bottom tabs providing information
regarding the fonts computed for the currently selected DOM node.
(cherry picked from commit c3e69f2fc6ced035f59f3c78f54556a372d2fd14)
The media queries for the different themes were all over the place,
they got consolidated in one place specifying all the colors. :^)
(cherry picked from commit ae25146b898ce8900d04c4911f1f0835681aac4e)
Previously, the legacy `-webkit-foo` properties would all be top of the
list, when they are generally not useful to inspect. Instead, put them
at the bottom, so that users can still see them if they want to, but
they're not in the way.
(cherry picked from commit 113b4da1df7ec65a8686af4e7b91e2f8d4114e2c)
The Inspector looks a bit nicer if we don't paint the horizontal scroll
bars unless we need to.
(cherry picked from commit 5c73a31b4f3e18acb783b6a5c6c9a479d2956de8)
Currently, the feel of scrolling containers in the Inspector is a bit
awkward. We make the entire split-view container scrollable, then we
absolutely position the tab control buttons to force them to not scroll.
The result is that the scroll bar is painted over the tab controls, and
the tab content that we actually want to scroll has to scroll under the
tab controls. This never looked quite right.
It was basically:
<div tab-container> <!-- Scrollable -->
<div tab-controls /> <!-- Pinned to not be scrollable -->
<div tab-content /> <!-- The part we actually want to scroll -->
</div>
This patch moves the "scrollability" to just the tab content. We then
don't need to go out of our way to ensure only the content is actually
scrollable.
So we now have:
<div tab-container> <!-- Not scrollable -->
<div tab-controls /> <!-- Not pinned, uses normal layout -->
<div tab-content /> <!-- Scrollable -->
</div>
(cherry picked from commit d2c775b0ca202aa9be81ab21b0c71a8f8ac005e3)
We currently display scroll bars for the JS console and its parent tab
container. We want the console output to be separately scrollable from
the tab content, but since both containers are scrollable, we end up
with nested scroll bars. This also makes actually scrolling feel pretty
awkward.
Prevent this by making the tab container non-scrollable when the JS
console is shown.
(cherry picked from commit 4795b9206cfeb2edf573461e02f0c148b9972a36)
Together with a first JSON file for bringing up a fully functional
BuggieBox container, we allow users to take advantage of the kernel
unsharing features that were introduced in earlier commits.
These 2 syscalls are responsible for unsharing resources in the system,
such as hostname, VFS root contexts and process lists.
Together with an appropriate userspace implementation, these syscalls
could be used for creating a sandbox environment (containers) for user
programs.
The whole concept of Jails was far more complicated than I actually want
it to be, so let's reduce the complexity of how it works from now on.
Please note that we always leaked the attach count of a Jail object in
the fork syscall if it failed midway.
Instead, we should have attach to the jail just before registering the
new Process, so we don't need to worry about unsuccessful Process
creation.
The reduction of complexity in regard to jails means that instead of
relying on jails to provide PID isolation, we could simplify the whole
idea of them to be a simple SetOnce, and let the ProcessList (now called
ScopedProcessList) to be responsible for this type of isolation.
Therefore, we apply the following changes to do so:
- We make the Jail concept no longer a class of its own. Instead, we
simplify the idea of being jailed to a simple ProtectedValues boolean
flag. This means that we no longer check of matching jail pointers
anywhere in the Kernel code.
To set a process as jailed, a new prctl option was added to set a
Kernel SetOnce boolean flag (so it cannot change ever again).
- We provide Process & Thread methods to iterate over process lists.
A process can either iterate on the global process list, or if it's
attached to a scoped process list, then only over that list.
This essentially replaces the need of checking the Jail pointer of a
process when iterating over process lists.
Instead, simplify things by allowing the user to specify a specific
device entry in the configuration file, by specifying a minor number.
The first example of such device is the /dev/beep, as it resides on the
"generic" device node family (as it has a major number of 1).
However, because it can be skipped (if the user disables the beep device
through a kernel commandline option), we can't just create it blindly.
Therefore, when iterating on the configuration file the DeviceMapper
code detects the entry has a specific minor number of 10, and creates
a special DeviceNodeMatch (with a specific minor number being included).
When an event from /dev/devctl that notifies on the existence of the
/dev/beep device arrives, we find this specific match and don't create
an actual DeviceNodeFamily object, but rather blindly create a device
node.Mapper: Remove the concept of pluggable once devices
Instead, let the user define them through a configuration file which can
be written with the assistance of /sys/kernel/chardev_major_allocs and
/sys/kernel/blockdev_major_allocs files.
This utility lists all devices' major number allocations, for character
and block devices. It can help the user to figure out the DeviceMapper
service manages spawning of device nodes in /dev and other associated
files under the /tmp/system/devicemap directory.
- Document exactly which crash features are available on which
architectures. There's several interesting crash tests we will want to
add for specific architectures, such as misaligned memory accesses.
- Don't compile the divide by zero crash test on RISC-V, as they simply
don't crash here.
- Rename the test for "x86 User Mode Instruction Prevention" to a more
generic "try to execute a priviledged instruction"; whatever that
specifically entails on any given architecture.
- Rename a bunch of internal variables to more generic names.
- Wrap the x86-specific implementation of "execute non executable
memory" in architecture preprocessor checks.
