mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-23 09:46:04 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Kernel/run

86 lines
2.8 KiB
Text
Raw Normal View History

Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
#!/bin/sh
run: Make it easy to override which qemu executable is used. Patch contributed by "pd"
2019-05-04 02:51:50 +02:00
[ -z "$SERENITY_QEMU_BIN" ] && SERENITY_QEMU_BIN="qemu-system-i386"
Kernel: Expose kernel command line to userspace through /proc/cmdline
2019-06-16 14:05:07 +02:00
[ -z "$SERENITY_KERNEL_CMDLINE" ] && SERENITY_KERNEL_CMDLINE="hello"
Kernel: Make better use of the multiboot info. Define the multiboot info struct properly so we don't have to grab at byte offsets in the memory access checker code. Also print kernel command line in init().
2019-06-02 09:50:18 +02:00
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
[ -z "$SERENITY_RAM_SIZE" ] && SERENITY_RAM_SIZE=128M
Fix jittery mouse
2019-05-01 22:45:17 +03:00
export SDL_VIDEO_X11_DGAMOUSE=0
Give the emulator testing environments 128 MB of RAM. I'm working on porting GCC and it needs a fair bit of memory to run.
2019-03-27 13:02:29 +01:00
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 12:43:45 +01:00
if [ "$1" = "b" ]; then
# ./run b: bochs
bochs -q -f .bochsrc
elif [ "$1" = "qn" ]; then
# ./run qn: qemu without network
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
$SERENITY_QEMU_BIN -s -m $SERENITY_RAM_SIZE \
Allow passing extra args to qemu via a SERENITY_EXTRA_QEMU_ARGS env var.
2019-04-24 21:06:16 +02:00
$SERENITY_EXTRA_QEMU_ARGS \
Run QEMU with the "guest_errors" debug flag, in case we do something wrong.
2019-05-17 18:19:03 +02:00
-d cpu_reset,guest_errors \
WindowServer: Add 2560x1440 resolution option. Also expand the QEMU VGA memory size to 64 MB, since otherwise we won't have enough memory for double-buffering the screen.
2019-05-24 14:02:17 +02:00
-device VGA,vgamem_mb=64 \
Always run QEMU with -debugcon stdio. If someone wants to run without this, they can disable it manually :^)
2019-05-23 20:57:32 +02:00
-debugcon stdio \
Allow passing extra args to qemu via a SERENITY_EXTRA_QEMU_ARGS env var.
2019-04-24 21:06:16 +02:00
-device e1000 \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-kernel kernel \
Kernel: Expose kernel command line to userspace through /proc/cmdline
2019-06-16 14:05:07 +02:00
-append "${SERENITY_KERNEL_CMDLINE}" \
Kernel: Implement OffsetDiskDevice to prepare for partition support This implements a passthrough disk driver that translates the read/write block addresses by a fixed offset. This could form the basis of MBR partition support if we were to parse the MBR table at boot and create that OffsetDiskDevice dynamically, rather than seeking to a fixed offset. This also introduces a dependency in the form of grub. You'll need to have 32-bit grub binaries installed to build the project now. As a bonus, divorcing Serenity from qemu's kernel loading means we can now *technically* boot on real hardware. It just... doesn't get very far yet. If you write the `_disk_image` file to an IDE hard drive and boot it in a machine that supports all the basic PC hardware, it *will* start loading the kernel.
2019-06-02 18:58:59 +10:00
-hda _disk_image \
Kernel: First cut of a sb16 driver Also add an AudioServer that (right now) doesn't do much. It tries to open, parse, and play a wav file. In the future, it can do more. My general thinking here here is that /dev/audio will be "owned" by AudioServer, and we'll do mixing in software before passing buffers off to the kernel to play, but we have to start somewhere.
2019-07-12 19:28:01 +02:00
-soundhw pcspk \
-soundhw sb16
More work on IPv4 sockets and /bin/ping. It's now actually possible to ping other hosts on the network! :^) I've switched the "run" script over to starting QEMU with user networking since that works better for my testing needs right now.
2019-03-13 03:26:01 +01:00
elif [ "$1" = "qtap" ]; then
# ./run qtap: qemu with tap
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
sudo $SERENITY_QEMU_BIN -s -m $SERENITY_RAM_SIZE \
Allow passing extra args to qemu via a SERENITY_EXTRA_QEMU_ARGS env var.
2019-04-24 21:06:16 +02:00
$SERENITY_EXTRA_QEMU_ARGS \
Runner: Enable QEMU's KVM mode by default This makes QEMU run significantly faster on Linux systems with KVM.
2019-10-13 15:07:23 +02:00
-enable-kvm \
Run QEMU with the "guest_errors" debug flag, in case we do something wrong.
2019-05-17 18:19:03 +02:00
-d cpu_reset,guest_errors \
WindowServer: Add 2560x1440 resolution option. Also expand the QEMU VGA memory size to 64 MB, since otherwise we won't have enough memory for double-buffering the screen.
2019-05-24 14:02:17 +02:00
-device VGA,vgamem_mb=64 \
Always run QEMU with -debugcon stdio. If someone wants to run without this, they can disable it manually :^)
2019-05-23 20:57:32 +02:00
-debugcon stdio \
Allow passing extra args to qemu via a SERENITY_EXTRA_QEMU_ARGS env var.
2019-04-24 21:06:16 +02:00
-object filter-dump,id=hue,netdev=br0,file=e1000.pcap \
-netdev tap,ifname=tap0,id=br0 \
-device e1000,netdev=br0 \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-kernel kernel \
Kernel: Expose kernel command line to userspace through /proc/cmdline
2019-06-16 14:05:07 +02:00
-append "${SERENITY_KERNEL_CMDLINE}" \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-hda _disk_image \
Kernel: First cut of a sb16 driver Also add an AudioServer that (right now) doesn't do much. It tries to open, parse, and play a wav file. In the future, it can do more. My general thinking here here is that /dev/audio will be "owned" by AudioServer, and we'll do mixing in software before passing buffers off to the kernel to play, but we have to start somewhere.
2019-07-12 19:28:01 +02:00
-soundhw pcspk \
-soundhw sb16
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
elif [ "$1" = "qgrub" ]; then
# ./run qgrub: qemu with grub
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
$SERENITY_QEMU_BIN -s -m $SERENITY_RAM_SIZE \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
$SERENITY_EXTRA_QEMU_ARGS \
Runner: Enable QEMU's KVM mode by default This makes QEMU run significantly faster on Linux systems with KVM.
2019-10-13 15:07:23 +02:00
-enable-kvm \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-d cpu_reset,guest_errors \
-device VGA,vgamem_mb=64 \
-debugcon stdio \
-object filter-dump,id=hue,netdev=breh,file=e1000.pcap \
Runner: Forward host TCP port 8823 to guest port 23 in QEMU This makes it easier to test TelnetServer when running in QEMU.
2019-09-09 09:19:43 +02:00
-netdev user,id=breh,hostfwd=tcp:127.0.0.1:8888-10.0.2.15:8888,hostfwd=tcp:127.0.0.1:8823-10.0.2.15:23 \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-device e1000,netdev=breh \
Kernel: Implement OffsetDiskDevice to prepare for partition support This implements a passthrough disk driver that translates the read/write block addresses by a fixed offset. This could form the basis of MBR partition support if we were to parse the MBR table at boot and create that OffsetDiskDevice dynamically, rather than seeking to a fixed offset. This also introduces a dependency in the form of grub. You'll need to have 32-bit grub binaries installed to build the project now. As a bonus, divorcing Serenity from qemu's kernel loading means we can now *technically* boot on real hardware. It just... doesn't get very far yet. If you write the `_disk_image` file to an IDE hard drive and boot it in a machine that supports all the basic PC hardware, it *will* start loading the kernel.
2019-06-02 18:58:59 +10:00
-hda _disk_image \
Kernel: Add a beep() syscall that beeps the PC speaker. Hook this up in Terminal so that the '\a' character generates a beep. Finally emit an '\a' character in the shell line editing code when backspacing at the start of the line.
2019-05-15 21:40:41 +02:00
-soundhw pcspk
Kernel: Enabling Text mode debugging (#696) Also added an option to start Serenity with text mode in QEMU in the run script.
2019-10-29 17:41:40 +02:00
elif [ "$1" = "qtext" ]; then
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
$SERENITY_QEMU_BIN -s -m $SERENITY_RAM_SIZE \
Kernel: Enabling Text mode debugging (#696) Also added an option to start Serenity with text mode in QEMU in the run script.
2019-10-29 17:41:40 +02:00
$SERENITY_EXTRA_QEMU_ARGS \
-d cpu_reset,guest_errors \
-device VGA,vgamem_mb=64 \
-debugcon stdio \
-device e1000 \
-kernel kernel \
-append "${SERENITY_KERNEL_CMDLINE} text_debug" \
-hda _disk_image \
-soundhw pcspk \
-soundhw sb16
More work on IPv4 sockets and /bin/ping. It's now actually possible to ping other hosts on the network! :^) I've switched the "run" script over to starting QEMU with user networking since that works better for my testing needs right now.
2019-03-13 03:26:01 +01:00
else
# ./run: qemu with user networking
Run: Properly use common memory size
2019-11-01 17:46:39 -05:00
$SERENITY_QEMU_BIN -s -m $SERENITY_RAM_SIZE \
Allow passing extra args to qemu via a SERENITY_EXTRA_QEMU_ARGS env var.
2019-04-24 21:06:16 +02:00
$SERENITY_EXTRA_QEMU_ARGS \
Runner: Enable QEMU's KVM mode by default This makes QEMU run significantly faster on Linux systems with KVM.
2019-10-13 15:07:23 +02:00
-enable-kvm \
Run QEMU with the "guest_errors" debug flag, in case we do something wrong.
2019-05-17 18:19:03 +02:00
-d cpu_reset,guest_errors \
WindowServer: Add 2560x1440 resolution option. Also expand the QEMU VGA memory size to 64 MB, since otherwise we won't have enough memory for double-buffering the screen.
2019-05-24 14:02:17 +02:00
-device VGA,vgamem_mb=64 \
Always run QEMU with -debugcon stdio. If someone wants to run without this, they can disable it manually :^)
2019-05-23 20:57:32 +02:00
-debugcon stdio \
IPv4: Begin fleshing out TCP support.
2019-03-13 17:17:07 +01:00
-object filter-dump,id=hue,netdev=breh,file=e1000.pcap \
Runner: Forward host TCP port 8823 to guest port 23 in QEMU This makes it easier to test TelnetServer when running in QEMU.
2019-09-09 09:19:43 +02:00
-netdev user,id=breh,hostfwd=tcp:127.0.0.1:8888-10.0.2.15:8888,hostfwd=tcp:127.0.0.1:8823-10.0.2.15:23 \
IPv4: Begin fleshing out TCP support.
2019-03-13 17:17:07 +01:00
-device e1000,netdev=breh \
Build: Remove grub from default build process This removes grub and all the loopback device business from the default build process. Running grub takes about a second, and it turns out it's inconsistently packaged in different distributions, which has led to at least one confusing issue so far (grub-install vs grub2-install). Removing it from the basic path will make it easier for people to try Serenity out. There are now two scripts that can be used to build a disk image: 1. `build-image-grub.sh` - this will build an image suitable for writing to the IDE hard drive of a physical machine, complete with a partition table and bootloader. This can be run in qemu with the `qgrub` target for the `run` script. 2. `build-image-qemu.sh` - this is a simpler script which creates a bare filesystem image rather than a full MBR disk. Both of these call out to `build-root-filesystem.sh` to do most of the work setting up... the root filesystem. For completeness' sake, I've retained the `sync.sh` script as a simple forwarding to `build-image-qemu.sh`. This relies on the functionality from #194 and #195. #195 allows us to use `/dev/hda` as the root device when nothing else is specified, and #194 works around a strange feature of qemu that appends a space to the kernel command line.
2019-06-04 22:16:30 +10:00
-kernel kernel \
Kernel: Expose kernel command line to userspace through /proc/cmdline
2019-06-16 14:05:07 +02:00
-append "${SERENITY_KERNEL_CMDLINE}" \
Kernel: Implement OffsetDiskDevice to prepare for partition support This implements a passthrough disk driver that translates the read/write block addresses by a fixed offset. This could form the basis of MBR partition support if we were to parse the MBR table at boot and create that OffsetDiskDevice dynamically, rather than seeking to a fixed offset. This also introduces a dependency in the form of grub. You'll need to have 32-bit grub binaries installed to build the project now. As a bonus, divorcing Serenity from qemu's kernel loading means we can now *technically* boot on real hardware. It just... doesn't get very far yet. If you write the `_disk_image` file to an IDE hard drive and boot it in a machine that supports all the basic PC hardware, it *will* start loading the kernel.
2019-06-02 18:58:59 +10:00
-hda _disk_image \
Kernel: First cut of a sb16 driver Also add an AudioServer that (right now) doesn't do much. It tries to open, parse, and play a wav file. In the future, it can do more. My general thinking here here is that /dev/audio will be "owned" by AudioServer, and we'll do mixing in software before passing buffers off to the kernel to play, but we have to start somewhere.
2019-07-12 19:28:01 +02:00
-soundhw pcspk \
-soundhw sb16
Allow running in QEMU with "./run q" The kernel doesn't run in QEMU right now and I don't know why.
2018-10-17 16:58:35 +02:00
fi
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Reference in a new issue Copy permalink