system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-09-16 06:30:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move WindowServer to userspace.

Browse source 
This is a monster patch that required changing a whole bunch of things.
There are performance and stability issues all over the place, but it works.
Pretty cool, I have to admit :^)
This commit is contained in:
Andreas Kling 2019-02-17 00:13:47 +01:00
parent 0b1b21d622
commit 640360e958
41 changed files with 325 additions and 463 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Kernel/BochsVGADevice.cpp
View file

@ -95,9 +95,9 @@ Region* BochsVGADevice::mmap(Process& process, LinearAddress preferred_laddr, si
0,
"BochsVGA Framebuffer",
true, true);
kprintf("BochsVGA: %s(%u) created Region{%p} for framebuffer P%x\n",
kprintf("BochsVGA: %s(%u) created Region{%p} with size %u for framebuffer P%x with laddr L%x\n",
process.name().characters(), process.pid(),
region, framebuffer_address().as_ptr());
region, region->size(), framebuffer_address().as_ptr(), region->laddr().get());
ASSERT(region);
return region;
}

6
Kernel/FileDescriptor.cpp
View file

@ -10,6 +10,7 @@
#include <Kernel/Socket.h>
#include <Kernel/Process.h>
#include <Kernel/BlockDevice.h>
#include <Kernel/MemoryManager.h>
RetainPtr<FileDescriptor> FileDescriptor::create(RetainPtr<Inode>&& inode)
{
@ -54,6 +55,10 @@ FileDescriptor::FileDescriptor(RetainPtr<Socket>&& socket, SocketRole role)
FileDescriptor::~FileDescriptor()
{
if (m_socket) {
m_socket->close(m_socket_role);
m_socket = nullptr;
}
if (m_device) {
m_device->close();
m_device = nullptr;
@ -364,6 +369,7 @@ Region* FileDescriptor::mmap(Process& process, LinearAddress laddr, size_t offse
// FIXME: Implement mapping at a client-specified address. Most of the support is already in plcae.
ASSERT(laddr.as_ptr() == nullptr);
auto* region = process.allocate_file_backed_region(LinearAddress(), size, inode(), move(region_name), prot & PROT_READ, prot & PROT_WRITE);
region->page_in();
return region;
}

17
Kernel/KeyCode.h
View file

@ -108,3 +108,20 @@ enum KeyCode : byte {
Key_Tilde,
Key_Backtick,
};
enum KeyModifier {
Mod_Alt = 0x01,
Mod_Ctrl = 0x02,
Mod_Shift = 0x04,
Is_Press = 0x80,
};
struct KeyEvent {
KeyCode key { Key_Invalid };
byte character { 0 };
byte flags { 0 };
bool alt() const { return flags & Mod_Alt; }
bool ctrl() const { return flags & Mod_Ctrl; }
bool shift() const { return flags & Mod_Shift; }
bool is_press() const { return flags & Is_Press; }
};

17
Kernel/Keyboard.h
View file

@ -12,22 +12,7 @@ class KeyboardClient;
class Keyboard final : public IRQHandler, public CharacterDevice {
AK_MAKE_ETERNAL
public:
enum Modifier {
Mod_Alt = 0x01,
Mod_Ctrl = 0x02,
Mod_Shift = 0x04,
Is_Press = 0x80,
};
struct Event {
KeyCode key { Key_Invalid };
byte character { 0 };
byte flags { 0 };
bool alt() const { return flags & Mod_Alt; }
bool ctrl() const { return flags & Mod_Ctrl; }
bool shift() const { return flags & Mod_Shift; }
bool is_press() const { return flags & Is_Press; }
};
using Event = KeyEvent;
[[gnu::pure]] static Keyboard& the();

35
Kernel/LocalSocket.cpp
View file

@ -106,37 +106,54 @@ bool LocalSocket::connect(const sockaddr* address, socklen_t address_size, int&
return true;
}
void LocalSocket::close(SocketRole role)
{
if (role == SocketRole::Accepted)
m_server_closed = true;
else if (role == SocketRole::Connected)
m_client_closed = true;
}
bool LocalSocket::can_read(SocketRole role) const
{
if (m_bound && is_listening())
return can_accept();
if (role == SocketRole::Accepted)
return !m_for_server.is_empty();
else
return !m_for_client.is_empty();
return m_client_closed || !m_for_server.is_empty();
else if (role == SocketRole::Connected)
return m_server_closed || !m_for_client.is_empty();
ASSERT_NOT_REACHED();
}
ssize_t LocalSocket::read(SocketRole role, byte* buffer, size_t size)
{
if (role == SocketRole::Accepted)
return m_for_server.read(buffer, size);
else
else if (role == SocketRole::Connected)
return m_for_client.read(buffer, size);
ASSERT_NOT_REACHED();
}
ssize_t LocalSocket::write(SocketRole role, const byte* data, size_t size)
{
if (role == SocketRole::Accepted)
if (role == SocketRole::Accepted) {
if (m_client_closed)
return -EPIPE;
return m_for_client.write(data, size);
else
} else if (role == SocketRole::Connected) {
if (m_client_closed)
return -EPIPE;
return m_for_server.write(data, size);
}
ASSERT_NOT_REACHED();
}
bool LocalSocket::can_write(SocketRole role) const
{
if (role == SocketRole::Accepted)
return m_for_client.bytes_in_write_buffer() < 4096;
else
return m_for_server.bytes_in_write_buffer() < 4096;
return m_client_closed || m_for_client.bytes_in_write_buffer() < 4096;
else if (role == SocketRole::Connected)
return m_server_closed || m_for_server.bytes_in_write_buffer() < 4096;
ASSERT_NOT_REACHED();
}

4
Kernel/LocalSocket.h
View file

@ -13,7 +13,7 @@ public:
virtual bool bind(const sockaddr*, socklen_t, int& error) override;
virtual bool connect(const sockaddr*, socklen_t, int& error) override;
virtual bool get_address(sockaddr*, socklen_t*) override;
virtual void close(SocketRole) override;
virtual bool can_read(SocketRole) const override;
virtual ssize_t read(SocketRole, byte*, size_t) override;
virtual ssize_t write(SocketRole, const byte*, size_t) override;
@ -27,6 +27,8 @@ private:
RetainPtr<LocalSocket> m_peer;
bool m_bound { false };
bool m_server_closed { false };
bool m_client_closed { false };
sockaddr_un m_address;
DoubleBuffer m_for_client;

24
Kernel/Makefile
View file

@ -51,26 +51,6 @@ VFS_OBJS = \
FileDescriptor.o \
SyntheticFileSystem.o
SHAREDGRAPHICS_OBJS = \
../SharedGraphics/Rect.o \
../SharedGraphics/Painter.o \
../SharedGraphics/Font.o \
../SharedGraphics/Color.o \
../SharedGraphics/CharacterBitmap.o \
../SharedGraphics/GraphicsBitmap.o
WINDOWSERVER_OBJS = \
../WindowServer/WSMessageReceiver.o \
../WindowServer/WSMessageLoop.o \
../WindowServer/WSWindow.o \
../WindowServer/WSWindowManager.o \
../WindowServer/WSScreen.o \
../WindowServer/WSMenuBar.o \
../WindowServer/WSMenu.o \
../WindowServer/WSMenuItem.o \
../WindowServer/WSClientConnection.o \
../WindowServer/main.o
AK_OBJS = \
../AK/String.o \
../AK/StringImpl.o \
@ -78,7 +58,7 @@ AK_OBJS = \
../AK/FileSystemPath.o \
../AK/StdLibExtras.o
OBJS = $(KERNEL_OBJS) $(VFS_OBJS) $(AK_OBJS) $(WINDOWSERVER_OBJS) $(SHAREDGRAPHICS_OBJS)
OBJS = $(KERNEL_OBJS) $(VFS_OBJS) $(AK_OBJS)
NASM = nasm
KERNEL = kernel
@ -89,7 +69,7 @@ STANDARD_FLAGS = -std=c++17 -nostdinc++ -nostdlib -nostdinc
KERNEL_FLAGS = -ffreestanding -fno-stack-protector -fno-ident -fno-builtin
WARNING_FLAGS = -Wextra -Wall -Wundef -Wcast-qual -Wwrite-strings -Wimplicit-fallthrough
FLAVOR_FLAGS = -mregparm=3 -march=i386 -m32 -fno-exceptions -fno-rtti -fmerge-all-constants -fno-unroll-loops -fno-pie -fno-pic
OPTIMIZATION_FLAGS = -Oz -fno-asynchronous-unwind-tables -fno-omit-frame-pointer
OPTIMIZATION_FLAGS = -Os -fno-asynchronous-unwind-tables -fno-omit-frame-pointer
INCLUDE_FLAGS = -I.. -I.
#SUGGEST_FLAGS = -Wsuggest-final-types -Wsuggest-final-methods -Wsuggest-override #-Wsuggest-attribute=noreturn

7
Kernel/MemoryManager.cpp
View file

@ -581,9 +581,12 @@ bool MemoryManager::validate_user_write(const Process& process, LinearAddress la
RetainPtr<Region> Region::clone()
{
InterruptDisabler disabler;
if (m_shared || (m_readable && !m_writable)) {
dbgprintf("%s<%u> Region::clone(): sharing %s (L%x)\n",
current->name().characters(),
current->pid(),
m_name.characters(),
laddr().get());
// Create a new region backed by the same VMObject.
return adopt(*new Region(laddr(), size(), m_vmo.copy_ref(), m_offset_in_vmo, String(m_name), m_readable, m_writable));
}

1
Kernel/MemoryManager.h
View file

@ -142,6 +142,7 @@ public:
const VMObject& vmo() const { return *m_vmo; }
VMObject& vmo() { return *m_vmo; }
bool is_shared() const { return m_shared; }
void set_shared(bool shared) { m_shared = shared; }
bool is_bitmap() const { return m_is_bitmap; }

41
Kernel/Process.cpp
View file

@ -18,16 +18,17 @@
#include "Scheduler.h"
#include "FIFO.h"
#include "KSyms.h"
#include <WindowServer/WSMessageLoop.h>
#include <Kernel/Socket.h>
#include "MasterPTY.h"
#include "elf.h"
#include <AK/StringBuilder.h>
//#define DEBUG_IO
//#define TASK_DEBUG
//#define FORK_DEBUG
#define SIGNAL_DEBUG
#define MAX_PROCESS_GIDS 32
//#define SHARED_BUFFER_DEBUG
static const dword default_kernel_stack_size = 16384;
static const dword default_userspace_stack_size = 65536;
@ -49,7 +50,6 @@ void Process::initialize()
s_hostname = new String("courage");
s_hostname_lock = new Lock;
Scheduler::initialize();
new WSMessageLoop;
}
Vector<pid_t> Process::all_pids()
@ -167,11 +167,11 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
if ((dword)addr & ~PAGE_MASK)
return (void*)-EINVAL;
if (flags & MAP_ANONYMOUS) {
// FIXME: Implement mapping at a client-specified address. Most of the support is already in plcae.
ASSERT(addr == nullptr);
auto* region = allocate_region(LinearAddress(), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false);
auto* region = allocate_region(LinearAddress((dword)addr), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false);
if (!region)
return (void*)-ENOMEM;
if (flags & MAP_SHARED)
region->set_shared(true);
return region->laddr().as_ptr();
}
if (offset & ~PAGE_MASK)
@ -184,6 +184,8 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
auto* region = descriptor->mmap(*this, LinearAddress((dword)addr), offset, size, prot);
if (!region)
return (void*)-ENOMEM;
if (flags & MAP_SHARED)
region->set_shared(true);
return region->laddr().as_ptr();
}
@ -191,9 +193,9 @@ int Process::sys$munmap(void* addr, size_t size)
{
auto* region = region_from_range(LinearAddress((dword)addr), size);
if (!region)
return -1;
return -EINVAL;
if (!deallocate_region(*region))
return -1;
return -EINVAL;
return 0;
}
@ -2136,9 +2138,6 @@ void Process::finalize()
{
ASSERT(current == g_finalizer);
if (WSMessageLoop::the().running())
WSMessageLoop::the().notify_client_died(gui_client_id());
m_fds.clear();
m_tty = nullptr;
disown_all_shared_buffers();
@ -2367,13 +2366,17 @@ struct SharedBuffer {
{
if (m_pid1 == process.pid()) {
++m_pid1_retain_count;
if (!m_pid1_region)
if (!m_pid1_region) {
m_pid1_region = process.allocate_region_with_vmo(LinearAddress(), size(), m_vmo.copy_ref(), 0, "SharedBuffer", true, true);
m_pid1_region->set_shared(true);
}
return m_pid1_region->laddr().as_ptr();
} else if (m_pid2 == process.pid()) {
++m_pid2_retain_count;
if (!m_pid2_region)
if (!m_pid2_region) {
m_pid2_region = process.allocate_region_with_vmo(LinearAddress(), size(), m_vmo.copy_ref(), 0, "SharedBuffer", true, true);
m_pid2_region->set_shared(true);
}
return m_pid2_region->laddr().as_ptr();
}
return nullptr;
@ -2445,7 +2448,9 @@ void SharedBuffer::destroy_if_unused()
{
if (!m_pid1_retain_count && !m_pid2_retain_count) {
LOCKER(shared_buffers().lock());
kprintf("Destroying unused SharedBuffer{%p} (pid1: %d, pid2: %d)\n", this, m_pid1, m_pid2);
#ifdef SHARED_BUFFER_DEBUG
dbgprintf("Destroying unused SharedBuffer{%p} (pid1: %d, pid2: %d)\n", this, m_pid1, m_pid2);
#endif
shared_buffers().resource().remove(m_shared_buffer_id);
}
}
@ -2474,7 +2479,11 @@ int Process::sys$create_shared_buffer(pid_t peer_pid, size_t size, void** buffer
int shared_buffer_id = ++s_next_shared_buffer_id;
auto shared_buffer = make<SharedBuffer>(m_pid, peer_pid, size);
shared_buffer->m_pid1_region = allocate_region_with_vmo(LinearAddress(), shared_buffer->size(), shared_buffer->m_vmo.copy_ref(), 0, "SharedBuffer", true, true);
shared_buffer->m_pid1_region->set_shared(true);
*buffer = shared_buffer->m_pid1_region->laddr().as_ptr();
#ifdef SHARED_BUFFER_DEBUG
dbgprintf("%s(%u): Created shared buffer %d (%u bytes, vmo is %u) for sharing with %d\n", name().characters(), pid(),shared_buffer_id, size, shared_buffer->size(), peer_pid);
#endif
shared_buffers().resource().set(shared_buffer_id, move(shared_buffer));
return shared_buffer_id;
}
@ -2486,6 +2495,9 @@ int Process::sys$release_shared_buffer(int shared_buffer_id)
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
#ifdef SHARED_BUFFER_DEBUG
dbgprintf("%s(%u): Releasing shared buffer %d\n", name().characters(), pid(), shared_buffer_id);
#endif
shared_buffer.release(*this);
return 0;
}
@ -2499,5 +2511,8 @@ void* Process::sys$get_shared_buffer(int shared_buffer_id)
auto& shared_buffer = *(*it).value;
if (shared_buffer.pid1() != m_pid && shared_buffer.pid2() != m_pid)
return (void*)-EINVAL;
#ifdef SHARED_BUFFER_DEBUG
dbgprintf("%s(%u): Retaining shared buffer %d\n", name().characters(), pid(), shared_buffer_id);
#endif
return shared_buffer.retain(*this);
}

3
Kernel/Process.h
View file

@ -48,9 +48,6 @@ struct DisplayInfo {
class Process : public InlineLinkedListNode<Process>, public Weakable<Process> {
friend class InlineLinkedListNode<Process>;
friend class WSWindowManager; // FIXME: Make a better API for allocate_region().
friend class GraphicsBitmap; // FIXME: Make a better API for allocate_region().
friend class Font; //FIXME: This is beyond gross.
public:
static Process* create_kernel_process(String&& name, void (*entry)());
static Process* create_user_process(const String& path, uid_t, gid_t, pid_t ppid, int& error, Vector<String>&& arguments = Vector<String>(), Vector<String>&& environment = Vector<String>(), TTY* = nullptr);

2
Kernel/Socket.h
View file

@ -28,7 +28,7 @@ public:
virtual bool connect(const sockaddr*, socklen_t, int& error) = 0;
virtual bool get_address(sockaddr*, socklen_t*) = 0;
virtual bool is_local() const { return false; }
virtual void close(SocketRole) = 0;
virtual bool can_read(SocketRole) const = 0;
virtual ssize_t read(SocketRole, byte*, size_t) = 0;
virtual ssize_t write(SocketRole, const byte*, size_t) = 0;

11
Kernel/init.cpp
View file

@ -25,9 +25,9 @@
#include "BochsVGADevice.h"
//#define SPAWN_GUITEST
#define SPAWN_LAUNCHER
//#define SPAWN_LAUNCHER
//#define SPAWN_GUITEST2
#define SPAWN_FILE_MANAGER
//#define SPAWN_FILE_MANAGER
//#define SPAWN_FONTEDITOR
//#define SPAWN_MULTIPLE_SHELLS
//#define STRESS_TEST_SPAWNING
@ -101,6 +101,10 @@ VFS* vfs;
int error;
Process::create_user_process("/bin/WindowServer", (uid_t)100, (gid_t)100, (pid_t)0, error, { }, { }, tty0);
if (error != 0) {
dbgprintf("error: %d\n", error);
}
//Process::create_user_process("/bin/sh", (uid_t)100, (gid_t)100, (pid_t)0, error, { }, move(environment), tty0);
Process::create_user_process("/bin/Terminal", (uid_t)100, (gid_t)100, (pid_t)0, error, { }, { }, tty0);
#ifdef SPAWN_GUITEST
@ -128,9 +132,6 @@ VFS* vfs;
Process::create_kernel_process("spawn_stress", spawn_stress);
#endif
extern void WindowServer_main();
Process::create_kernel_process("WindowServer", WindowServer_main);
current->sys$exit(0);
ASSERT_NOT_REACHED();
}

2
Kernel/makeall.sh
View file

@ -10,6 +10,8 @@ $make_cmd -C ../LibGUI clean && \
$make_cmd -C ../LibGUI && \
$make_cmd -C ../Userland clean && \
$make_cmd -C ../Userland && \
$make_cmd -C ../WindowServer clean && \
$make_cmd -C ../WindowServer && \
$make_cmd -C ../Applications/Terminal clean && \
$make_cmd -C ../Applications/Terminal && \
$make_cmd -C ../Applications/FontEditor clean && \

1
Kernel/sync.sh
View file

@ -69,6 +69,7 @@ cp -v ../Applications/Launcher/Launcher mnt/bin/Launcher
cp -v ../Applications/Clock/Clock mnt/bin/Clock
cp -v ../Applications/FileManager/FileManager mnt/bin/FileManager
cp -v ../Applications/About/About mnt/bin/About
cp -v ../WindowServer/WindowServer mnt/bin/WindowServer
cp -v kernel.map mnt/
sh sync-local.sh
umount mnt

2
LibC/Makefile
View file

@ -57,7 +57,7 @@ STANDARD_FLAGS = -std=c++17 -nostdinc++ -nostdlib -nostdinc
LIBC_FLAGS = -ffreestanding -fno-stack-protector -fno-ident
WARNING_FLAGS = -Wextra -Wall -Wundef -Wcast-qual -Wwrite-strings -Wimplicit-fallthrough
FLAVOR_FLAGS = -fomit-frame-pointer -march=i386 -m32 -fno-exceptions -fno-rtti -ffunction-sections -fdata-sections -fmerge-all-constants -fno-unroll-loops -fno-pie -fno-pic
OPTIMIZATION_FLAGS = -O2 -fno-asynchronous-unwind-tables
OPTIMIZATION_FLAGS = -Os -fno-asynchronous-unwind-tables
INCLUDE_FLAGS = -I.. -I.
DEFINES = -DSERENITY -DUSERLAND -DSANITIZE_PTRS

1
LibC/errno_numbers.h
View file

@ -47,6 +47,7 @@
__ERROR(EWHYTHO, "Failed without setting an error code (Bug!)") \
__ERROR(ENOTEMPTY, "Directory not empty") \
__ERROR(ECONNREFUSED, "Connection refused") \
__ERROR(EMAXERRNO, "The highest errno +1 :^)")
enum __errno_values {

6
LibC/unistd.cpp
View file

@ -357,7 +357,11 @@ int create_shared_buffer(pid_t peer_pid, size_t size, void** buffer)
void* get_shared_buffer(int shared_buffer_id)
{
int rc = syscall(SC_get_shared_buffer, shared_buffer_id);
__RETURN_WITH_ERRNO(rc, (void*)rc, (void*)-1);
if (rc < 0 && -rc < EMAXERRNO) {
errno = -rc;
return (void*)-1;
}
return (void*)rc;
}
int release_shared_buffer(int shared_buffer_id)

3
LibGUI/GEventLoop.cpp
View file

@ -40,7 +40,7 @@ GEventLoop::GEventLoop()
address.sun_family = AF_LOCAL;
strcpy(address.sun_path, "/wsportal");
int retries = 10;
int retries = 1000;
int rc = 0;
while (retries) {
rc = connect(m_event_fd, (const sockaddr*)&address, sizeof(address));
@ -53,6 +53,7 @@ GEventLoop::GEventLoop()
if (rc < 0) {
ASSERT_NOT_REACHED();
}
dbgprintf("(%u) GEventLoop constructed :)\n", getpid());
}
GEventLoop::~GEventLoop()

4
LibGUI/GWidget.cpp
View file

@ -7,6 +7,8 @@
#include <SharedGraphics/GraphicsBitmap.h>
#include <SharedGraphics/Painter.h>
#include <unistd.h>
GWidget::GWidget(GWidget* parent)
: GObject(parent)
{
@ -72,7 +74,9 @@ void GWidget::handle_paint_event(GPaintEvent& event)
Painter painter(*this);
painter.fill_rect(event.rect(), background_color());
}
dbgprintf("GWidget{%p} handle_paint_event %s before calling paint_event()\n", this, event.rect().to_string().characters());
paint_event(event);
dbgprintf("GWidget{%p} handle_paint_event %s after calling paint_event()\n", this, event.rect().to_string().characters());
for (auto* ch : children()) {
auto* child = (GWidget*)ch;
if (child->relative_rect().intersects(event.rect())) {

40
SharedGraphics/Font.cpp
View file

@ -3,20 +3,11 @@
#include <AK/BufferStream.h>
#include <AK/StdLibExtras.h>
#ifdef KERNEL
#include <Kernel/Process.h>
#include <Kernel/MemoryManager.h>
#include <Kernel/FileDescriptor.h>
#include <Kernel/VirtualFileSystem.h>
#endif
#ifdef USERLAND
#include <LibC/unistd.h>
#include <LibC/stdio.h>
#include <LibC/fcntl.h>
#include <LibC/errno.h>
#include <LibC/mman.h>
#endif
static const byte error_glyph_width = 8;
static const byte error_glyph_height = 10;
@ -54,19 +45,7 @@ Font& Font::default_font()
{
static const char* default_font_path = "/res/fonts/LizaRegular8x10.font";
if (!s_default_font) {
#ifdef USERLAND
s_default_font = Font::load_from_file(default_font_path).leak_ref();
#else
int error;
auto descriptor = VFS::the().open(default_font_path, error, 0, 0, *VFS::the().root_inode());
if (!descriptor) {
kprintf("Failed to open default font (%s)\n", default_font_path);
ASSERT_NOT_REACHED();
}
auto* region = current->allocate_file_backed_region(LinearAddress(), font_file_size(10), descriptor->inode(), "default_font", /*readable*/true, /*writable*/false);
ASSERT(region);
s_default_font = Font::load_from_memory(region->laddr().as_ptr()).leak_ref();
#endif
ASSERT(s_default_font);
}
return *s_default_font;
@ -76,19 +55,7 @@ Font& Font::default_bold_font()
{
static const char* default_bold_font_path = "/res/fonts/LizaBold8x10.font";
if (!s_default_bold_font) {
#ifdef USERLAND
s_default_bold_font = Font::load_from_file(default_bold_font_path).leak_ref();
#else
int error;
auto descriptor = VFS::the().open(default_bold_font_path, error, 0, 0, *VFS::the().root_inode());
if (!descriptor) {
kprintf("Failed to open default bold font (%s)\n", default_bold_font_path);
ASSERT_NOT_REACHED();
}
auto* region = current->allocate_file_backed_region(LinearAddress(), font_file_size(10), descriptor->inode(), "default_bold_font", /*readable*/true, /*writable*/false);
ASSERT(region);
s_default_bold_font = Font::load_from_memory(region->laddr().as_ptr()).leak_ref();
#endif
ASSERT(s_default_bold_font);
}
return *s_default_bold_font;
@ -116,6 +83,10 @@ Font::Font(const String& name, unsigned* rows, byte glyph_width, byte glyph_heig
Font::~Font()
{
if (m_mmap_ptr) {
int rc = munmap(m_mmap_ptr, 4096 * 3);
ASSERT(rc == 0);
}
}
RetainPtr<Font> Font::load_from_memory(const byte* data)
@ -134,7 +105,6 @@ RetainPtr<Font> Font::load_from_memory(const byte* data)
return adopt(*new Font(String(header.name), rows, header.glyph_width, header.glyph_height));
}
#ifdef USERLAND
RetainPtr<Font> Font::load_from_file(const String& path)
{
int fd = open(path.characters(), O_RDONLY, 0644);
@ -152,6 +122,7 @@ RetainPtr<Font> Font::load_from_file(const String& path)
}
auto font = load_from_memory(mapped_file);
font->m_mmap_ptr = mapped_file;
int rc = close(fd);
ASSERT(rc == 0);
@ -189,4 +160,3 @@ bool Font::write_to_file(const String& path)
ASSERT(rc == 0);
return true;
}
#endif

3
SharedGraphics/Font.h
View file

@ -47,10 +47,8 @@ public:
static RetainPtr<Font> load_from_memory(const byte*);
#ifdef USERLAND
static RetainPtr<Font> load_from_file(const String& path);
bool write_to_file(const String& path);
#endif
~Font();
@ -69,6 +67,7 @@ private:
String m_name;
unsigned* m_rows { nullptr };
void* m_mmap_ptr { nullptr };
RetainPtr<CharacterBitmap> m_error_bitmap;

57
SharedGraphics/GraphicsBitmap.cpp
View file

@ -1,18 +1,9 @@
#include "GraphicsBitmap.h"
#ifdef KERNEL
#include <Kernel/Process.h>
#include <Kernel/MemoryManager.h>
#include <WindowServer/WSMessageLoop.h>
#endif
#ifdef USERLAND
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#endif
RetainPtr<GraphicsBitmap> GraphicsBitmap::create(const Size& size)
{
@ -23,18 +14,9 @@ GraphicsBitmap::GraphicsBitmap(const Size& size)
: m_size(size)
, m_pitch(size.width() * sizeof(RGBA32))
{
#ifdef KERNEL
Syscall::SC_mmap_params params;
memset(&params, 0, sizeof(params));
params.fd = 0;
params.prot = PROT_READ | PROT_WRITE;
params.flags = MAP_ANONYMOUS | MAP_PRIVATE;
params.size = size.area() * sizeof(RGBA32);
params.offset = 0;
m_data = (RGBA32*)current->sys$mmap(&params);
m_data = (RGBA32*)mmap(nullptr, size.area() * sizeof(RGBA32), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
ASSERT(m_data && m_data != (void*)-1);
m_mmaped = true;
#endif
}
RetainPtr<GraphicsBitmap> GraphicsBitmap::create_wrapper(const Size& size, RGBA32* data)
@ -44,8 +26,6 @@ RetainPtr<GraphicsBitmap> GraphicsBitmap::create_wrapper(const Size& size, RGBA3
RetainPtr<GraphicsBitmap> GraphicsBitmap::load_from_file(const String& path, const Size& size)
{
RGBA32* mapped_data = nullptr;
#ifdef USERLAND
int fd = open(path.characters(), O_RDONLY, 0644);
if (fd < 0) {
dbgprintf("open(%s) got fd=%d, failed: %s\n", path.characters(), fd, strerror(errno));
@ -53,35 +33,17 @@ RetainPtr<GraphicsBitmap> GraphicsBitmap::load_from_file(const String& path, con
return nullptr;
}
mapped_data = (RGBA32*)mmap(nullptr, size.area() * 4, PROT_READ, MAP_SHARED, fd, 0);
auto* mapped_data = (RGBA32*)mmap(nullptr, size.area() * 4, PROT_READ, MAP_SHARED, fd, 0);
if (mapped_data == MAP_FAILED) {
int rc = close(fd);
ASSERT(rc == 0);
return nullptr;
}
#else
int error;
auto descriptor = VFS::the().open(path, error, 0, 0, *VFS::the().root_inode());
if (!descriptor) {
kprintf("Failed to load GraphicsBitmap from file (%s)\n", path.characters());
return nullptr;
}
auto* region = WSMessageLoop::the().server_process().allocate_file_backed_region(LinearAddress(), size.area() * 4, descriptor->inode(), ".rgb file", /*readable*/true, /*writable*/false);
mapped_data = (RGBA32*)region->laddr().get();
#endif
#ifdef USERLAND
int rc = close(fd);
ASSERT(rc == 0);
#endif
auto bitmap = create_wrapper(size, mapped_data);
#ifdef KERNEL
bitmap->m_server_region = region;
#else
bitmap->m_mmaped = true;
#endif
return bitmap;
}
@ -95,11 +57,7 @@ GraphicsBitmap::GraphicsBitmap(const Size& size, RGBA32* data)
RetainPtr<GraphicsBitmap> GraphicsBitmap::create_with_shared_buffer(int shared_buffer_id, const Size& size, RGBA32* data)
{
if (!data) {
#ifdef KERNEL
void* shared_buffer = current->sys$get_shared_buffer(shared_buffer_id);
#else
void* shared_buffer = get_shared_buffer(shared_buffer_id);
#endif
if (!shared_buffer || shared_buffer == (void*)-1)
return nullptr;
data = (RGBA32*)shared_buffer;
@ -118,20 +76,11 @@ GraphicsBitmap::GraphicsBitmap(int shared_buffer_id, const Size& size, RGBA32* d
GraphicsBitmap::~GraphicsBitmap()
{
if (m_mmaped) {
#ifdef KERNEL
int rc = current->sys$munmap(m_data, m_size.area() * 4);
#else
int rc = munmap(m_data, m_size.area() * 4);
#endif
ASSERT(rc == 0);
}
if (m_shared_buffer_id != -1) {
int rc;
#ifdef KERNEL
rc = current->sys$release_shared_buffer(m_shared_buffer_id);
#else
rc = release_shared_buffer(m_shared_buffer_id);
#endif
int rc = release_shared_buffer(m_shared_buffer_id);
ASSERT(rc == 0);
}
m_data = nullptr;

13
SharedGraphics/GraphicsBitmap.h
View file

@ -7,8 +7,6 @@
#include <AK/RetainPtr.h>
#include <AK/AKString.h>
class Region;
class GraphicsBitmap : public Retainable<GraphicsBitmap> {
public:
static RetainPtr<GraphicsBitmap> create(const Size&);
@ -25,17 +23,10 @@ public:
int width() const { return m_size.width(); }
int height() const { return m_size.height(); }
size_t pitch() const { return m_pitch; }
#ifdef KERNEL
Region* server_region() { return m_server_region; }
#endif
int shared_buffer_id() const { return m_shared_buffer_id; }
private:
#ifdef KERNEL
GraphicsBitmap(const Size&);
#endif
GraphicsBitmap(const Size&, RGBA32*);
GraphicsBitmap(int shared_buffer_id, const Size&, RGBA32*);
@ -44,10 +35,6 @@ private:
size_t m_pitch { 0 };
bool m_mmaped { false };
int m_shared_buffer_id { -1 };
#ifdef KERNEL
Region* m_server_region { nullptr };
#endif
};
inline RGBA32* GraphicsBitmap::scanline(int y)

13
SharedGraphics/Painter.cpp
View file

@ -4,7 +4,7 @@
#include <AK/Assertions.h>
#include <AK/StdLibExtras.h>
#ifdef USERLAND
#ifdef LIBGUI
#include <LibGUI/GWidget.h>
#include <LibGUI/GWindow.h>
#include <LibGUI/GEventLoop.h>
@ -22,7 +22,7 @@ Painter::Painter(GraphicsBitmap& bitmap)
m_clip_rect = { { 0, 0 }, bitmap.size() };
}
#ifdef USERLAND
#ifdef LIBGUI
Painter::Painter(GWidget& widget)
: m_font(&widget.font())
{
@ -30,7 +30,6 @@ Painter::Painter(GWidget& widget)
request.type = WSAPI_ClientMessage::Type::GetWindowBackingStore;
request.window_id = widget.window()->window_id();
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::DidGetWindowBackingStore);
m_backing_store_id = response.backing.backing_store_id;
m_target = GraphicsBitmap::create_with_shared_buffer(response.backing.shared_buffer_id, response.backing.size);
ASSERT(m_target);
@ -50,15 +49,7 @@ Painter::Painter(GWidget& widget)
Painter::~Painter()
{
#ifdef USERLAND
m_target = nullptr;
if (m_backing_store_id) {
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::ReleaseWindowBackingStore;
request.backing.backing_store_id = m_backing_store_id;
GEventLoop::main().post_message_to_server(request);
}
#endif
}
void Painter::fill_rect_with_draw_op(const Rect& a_rect, Color color)

7
SharedGraphics/Painter.h
View file

@ -11,7 +11,7 @@ class GlyphBitmap;
class GraphicsBitmap;
class Font;
#ifndef KERNEL
#ifdef USERLAND
class GWidget;
class GWindow;
#endif
@ -20,7 +20,7 @@ enum class TextAlignment { TopLeft, CenterLeft, Center, CenterRight };
class Painter {
public:
#ifndef KERNEL
#ifdef USERLAND
explicit Painter(GWidget&);
#endif
explicit Painter(GraphicsBitmap&);
@ -63,9 +63,8 @@ private:
Point m_translation;
Rect m_clip_rect;
RetainPtr<GraphicsBitmap> m_target;
#ifndef KERNEL
#ifdef LIBGUI
GWindow* m_window { nullptr };
void* m_backing_store_id { nullptr };
#endif
DrawOp m_draw_op { DrawOp::Copy };
};

1
WindowServer/.gitignore vendored
View file

@ -1,2 +1,3 @@
*.o
*.d
WindowServer

52
WindowServer/Makefile Normal file
View file

@ -0,0 +1,52 @@
SHAREDGRAPHICS_OBJS = \
../SharedGraphics/Painter.o \
../SharedGraphics/Font.o \
../SharedGraphics/Rect.o \
../SharedGraphics/GraphicsBitmap.o \
../SharedGraphics/CharacterBitmap.o \
../SharedGraphics/Color.o
WINDOWSERVER_OBJS = \
WSMessageReceiver.o \
WSMessageLoop.o \
WSWindow.o \
WSWindowManager.o \
WSScreen.o \
WSMenuBar.o \
WSMenu.o \
WSMenuItem.o \
WSClientConnection.o \
main.o
APP = WindowServer
OBJS = $(SHAREDGRAPHICS_OBJS) $(WINDOWSERVER_OBJS)
ARCH_FLAGS =
STANDARD_FLAGS = -std=c++17 -nostdinc++ -nostdlib -nostdinc
USERLAND_FLAGS = -ffreestanding -fno-stack-protector -fno-ident
WARNING_FLAGS = -Wextra -Wall -Wundef -Wcast-qual -Wwrite-strings -Wimplicit-fallthrough
FLAVOR_FLAGS = -march=i386 -m32 -fno-exceptions -fno-rtti -fmerge-all-constants -fno-unroll-loops -fno-pie -fno-pic
OPTIMIZATION_FLAGS = -Oz -fno-asynchronous-unwind-tables
INCLUDE_FLAGS = -I.. -I. -I../LibC
DEFINES = -DSERENITY -DSANITIZE_PTRS -DUSERLAND
CXXFLAGS = -MMD -MP $(WARNING_FLAGS) $(OPTIMIZATION_FLAGS) $(USERLAND_FLAGS) $(FLAVOR_FLAGS) $(ARCH_FLAGS) $(STANDARD_FLAGS) $(INCLUDE_FLAGS) $(DEFINES)
CXX = clang
LD = ld
AR = ar
LDFLAGS = -static --strip-debug -melf_i386 -e _start --gc-sections
all: $(APP)
$(APP): $(OBJS)
$(LD) -o $(APP) $(LDFLAGS) $(OBJS) ../LibC/LibC.a
.cpp.o:
@echo "CXX $<"; $(CXX) $(CXXFLAGS) -o $@ -c $<
-include $(OBJS:%.o=%.d)
clean:
@echo "CLEAN"; rm -f $(APPS) $(OBJS) *.d

6
WindowServer/WSAPITypes.h
View file

@ -34,7 +34,6 @@ struct WSAPI_WindowParameters {
};
struct WSAPI_WindowBackingStoreInfo {
void* backing_store_id;
WSAPI_Size size;
size_t bpp;
size_t pitch;
@ -114,7 +113,6 @@ struct WSAPI_ServerMessage {
unsigned identifier;
} menu;
struct {
void* backing_store_id;
WSAPI_Size size;
size_t bpp;
size_t pitch;
@ -143,7 +141,6 @@ struct WSAPI_ClientMessage {
InvalidateRect,
DidFinishPainting,
GetWindowBackingStore,
ReleaseWindowBackingStore,
SetGlobalCursorTracking,
};
Type type { Invalid };
@ -161,9 +158,6 @@ struct WSAPI_ClientMessage {
struct {
WSAPI_Rect rect;
} window;
struct {
void* backing_store_id;
} backing;
};
};

64
WindowServer/WSClientConnection.cpp
View file

@ -6,16 +6,18 @@
#include <WindowServer/WSWindow.h>
#include <WindowServer/WSWindowManager.h>
#include <WindowServer/WSAPITypes.h>
#include <Kernel/Process.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
Lockable<HashMap<int, WSClientConnection*>>* s_connections;
HashMap<int, WSClientConnection*>* s_connections;
void WSClientConnection::for_each_client(Function<void(WSClientConnection&)> callback)
{
if (!s_connections)
return;
LOCKER(s_connections->lock());
for (auto& it : s_connections->resource()) {
for (auto& it : *s_connections) {
callback(*it.value);
}
}
@ -24,36 +26,29 @@ WSClientConnection* WSClientConnection::from_client_id(int client_id)
{
if (!s_connections)
return nullptr;
LOCKER(s_connections->lock());
auto it = s_connections->resource().find(client_id);
if (it == s_connections->resource().end())
auto it = s_connections->find(client_id);
if (it == s_connections->end())
return nullptr;
return (*it).value;
}
WSClientConnection* WSClientConnection::ensure_for_client_id(int client_id)
{
if (auto* client = from_client_id(client_id))
return client;
return new WSClientConnection(client_id);
}
WSClientConnection::WSClientConnection(int fd)
: m_fd(fd)
{
int rc = current->sys$ioctl(m_fd, 413, (int)&m_pid);
static int s_next_client_id = 0;
m_client_id = ++s_next_client_id;
int rc = ioctl(m_fd, 413, (int)&m_pid);
ASSERT(rc == 0);
if (!s_connections)
s_connections = new Lockable<HashMap<int, WSClientConnection*>>;
LOCKER(s_connections->lock());
s_connections->resource().set(m_client_id, this);
s_connections = new HashMap<int, WSClientConnection*>;
s_connections->set(m_client_id, this);
}
WSClientConnection::~WSClientConnection()
{
LOCKER(s_connections->lock());
s_connections->resource().remove(m_client_id);
s_connections->remove(m_client_id);
}
void WSClientConnection::post_error(const String& error_message)
@ -69,14 +64,23 @@ void WSClientConnection::post_error(const String& error_message)
void WSClientConnection::post_message(const WSAPI_ServerMessage& message)
{
int nwritten = WSMessageLoop::the().server_process().sys$write(m_fd, &message, sizeof(message));
int nwritten = write(m_fd, &message, sizeof(message));
if (nwritten < 0) {
if (errno == EPIPE) {
dbgprintf("WSClientConnection::post_message: Disconnected from peer.\n");
return;
}
perror("WSClientConnection::post_message write");
ASSERT_NOT_REACHED();
}
ASSERT(nwritten == sizeof(message));
}
RetainPtr<GraphicsBitmap> WSClientConnection::create_bitmap(const Size& size)
RetainPtr<GraphicsBitmap> WSClientConnection::create_shared_bitmap(const Size& size)
{
RGBA32* buffer;
int shared_buffer_id = current->sys$create_shared_buffer(m_pid, size.area() * sizeof(RGBA32), (void**)&buffer);
int shared_buffer_id = create_shared_buffer(m_pid, size.area() * sizeof(RGBA32), (void**)&buffer);
ASSERT(shared_buffer_id >= 0);
ASSERT(buffer);
ASSERT(buffer != (void*)-1);
@ -352,13 +356,9 @@ void WSClientConnection::handle_request(WSAPIGetWindowBackingStoreRequest& reque
auto& window = *(*it).value;
auto* backing_store = window.backing();
// FIXME: It shouldn't work this way!
backing_store->retain();
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidGetWindowBackingStore;
response.window_id = window_id;
response.backing.backing_store_id = backing_store;
response.backing.bpp = sizeof(RGBA32);
response.backing.pitch = backing_store->pitch();
response.backing.size = backing_store->size();
@ -366,14 +366,6 @@ void WSClientConnection::handle_request(WSAPIGetWindowBackingStoreRequest& reque
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
void WSClientConnection::handle_request(WSAPIReleaseWindowBackingStoreRequest& request)
{
int backing_store_id = request.backing_store_id();
// FIXME: It shouldn't work this way!
auto* backing_store = (GraphicsBitmap*)backing_store_id;
backing_store->release();
}
void WSClientConnection::handle_request(WSAPISetGlobalCursorTrackingRequest& request)
{
int window_id = request.window_id();
@ -423,8 +415,6 @@ void WSClientConnection::on_request(WSAPIClientRequest& request)
return handle_request(static_cast<WSAPIDidFinishPaintingNotification&>(request));
case WSMessage::APIGetWindowBackingStoreRequest:
return handle_request(static_cast<WSAPIGetWindowBackingStoreRequest&>(request));
case WSMessage::APIReleaseWindowBackingStoreRequest:
return handle_request(static_cast<WSAPIReleaseWindowBackingStoreRequest&>(request));
case WSMessage::APISetGlobalCursorTrackingRequest:
return handle_request(static_cast<WSAPISetGlobalCursorTrackingRequest&>(request));
default:

4
WindowServer/WSClientConnection.h
View file

@ -19,11 +19,10 @@ public:
virtual ~WSClientConnection() override;
static WSClientConnection* from_client_id(int client_id);
static WSClientConnection* ensure_for_client_id(int client_id);
static void for_each_client(Function<void(WSClientConnection&)>);
void post_message(const WSAPI_ServerMessage&);
RetainPtr<GraphicsBitmap> create_bitmap(const Size&);
RetainPtr<GraphicsBitmap> create_shared_bitmap(const Size&);
int client_id() const { return m_client_id; }
WSMenuBar* app_menubar() { return m_app_menubar.ptr(); }
@ -52,7 +51,6 @@ private:
void handle_request(WSAPIInvalidateRectRequest&);
void handle_request(WSAPIDidFinishPaintingNotification&);
void handle_request(WSAPIGetWindowBackingStoreRequest&);
void handle_request(WSAPIReleaseWindowBackingStoreRequest&);
void handle_request(WSAPISetGlobalCursorTrackingRequest&);
void post_error(const String&);

15
WindowServer/WSMessage.h
View file

@ -38,7 +38,6 @@ public:
APIInvalidateRectRequest,
APIDidFinishPaintingNotification,
APIGetWindowBackingStoreRequest,
APIReleaseWindowBackingStoreRequest,
APISetGlobalCursorTrackingRequest,
__End_API_Client_Requests,
};
@ -353,20 +352,6 @@ private:
int m_window_id { 0 };
};
class WSAPIReleaseWindowBackingStoreRequest final : public WSAPIClientRequest {
public:
explicit WSAPIReleaseWindowBackingStoreRequest(int client_id, int backing_store_id)
: WSAPIClientRequest(WSMessage::APIReleaseWindowBackingStoreRequest, client_id)
, m_backing_store_id(backing_store_id)
{
}
int backing_store_id() const { return m_backing_store_id; }
private:
int m_backing_store_id { 0 };
};
class WSAPIDidFinishPaintingNotification final : public WSAPIClientRequest {
public:
explicit WSAPIDidFinishPaintingNotification(int client_id, int window_id, const Rect& rect)

188
WindowServer/WSMessageLoop.cpp
View file

@ -4,18 +4,21 @@
#include "WSWindowManager.h"
#include "WSScreen.h"
#include <WindowServer/WSClientConnection.h>
#include "PS2MouseDevice.h"
#include <Kernel/Keyboard.h>
#include <Kernel/KeyCode.h>
#include <WindowServer/WSAPITypes.h>
#include <AK/Bitmap.h>
#include "Process.h"
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
//#define WSEVENTLOOP_DEBUG
static WSMessageLoop* s_the;
WSMessageLoop::WSMessageLoop()
: m_lock("WSMessageLoop")
{
if (!s_the)
s_the = this;
@ -33,21 +36,19 @@ WSMessageLoop& WSMessageLoop::the()
int WSMessageLoop::exec()
{
ASSERT(m_server_process == current);
m_keyboard_fd = open("/dev/keyboard", O_RDONLY | O_NONBLOCK | O_CLOEXEC);
m_mouse_fd = open("/dev/psaux", O_RDONLY | O_NONBLOCK | O_CLOEXEC);
m_keyboard_fd = m_server_process->sys$open("/dev/keyboard", O_RDONLY);
m_mouse_fd = m_server_process->sys$open("/dev/psaux", O_RDONLY);
unlink("/wsportal");
m_server_process->sys$unlink("/wsportal");
m_server_fd = m_server_process->sys$socket(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK, 0);
m_server_fd = socket(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
ASSERT(m_server_fd >= 0);
sockaddr_un address;
address.sun_family = AF_LOCAL;
strcpy(address.sun_path, "/wsportal");
int rc = m_server_process->sys$bind(m_server_fd, (const sockaddr*)&address, sizeof(address));
int rc = bind(m_server_fd, (const sockaddr*)&address, sizeof(address));
ASSERT(rc == 0);
rc = m_server_process->sys$listen(m_server_fd, 5);
rc = listen(m_server_fd, 5);
ASSERT(rc == 0);
ASSERT(m_keyboard_fd >= 0);
@ -56,13 +57,7 @@ int WSMessageLoop::exec()
m_running = true;
for (;;) {
wait_for_message();
Vector<QueuedMessage> messages;
{
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
messages = move(m_queued_messages);
}
Vector<QueuedMessage> messages = move(m_queued_messages);
for (auto& queued_message : messages) {
auto* receiver = queued_message.receiver;
@ -81,12 +76,6 @@ int WSMessageLoop::exec()
}
}
Process* WSMessageLoop::process_from_client_id(int client_id)
{
// FIXME: This shouldn't work this way lol.
return (Process*)client_id;
}
void WSMessageLoop::post_message_to_client(int client_id, const WSAPI_ServerMessage& message)
{
auto* client = WSClientConnection::from_client_id(client_id);
@ -97,53 +86,16 @@ void WSMessageLoop::post_message_to_client(int client_id, const WSAPI_ServerMess
void WSMessageLoop::post_message(WSMessageReceiver* receiver, OwnPtr<WSMessage>&& message)
{
LOCKER(m_lock);
#ifdef WSEVENTLOOP_DEBUG
dbgprintf("WSMessageLoop::post_message: {%u} << receiver=%p, message=%p (type=%u)\n", m_queued_messages.size(), receiver, message.ptr(), message->type());
#endif
#if 0
if (message->type() == WSMessage::WM_ClientFinishedPaint) {
auto& invalidation_message = static_cast<WSClientFinishedPaintMessage&>(*message);
for (auto& queued_message : m_queued_messages) {
if (receiver == queued_message.receiver && queued_message.message->type() == WSMessage::WM_ClientFinishedPaint) {
auto& queued_invalidation_message = static_cast<WSClientFinishedPaintMessage&>(*queued_message.message);
if (queued_invalidation_message.rect().is_empty() || queued_invalidation_message.rect().contains(invalidation_message.rect())) {
#ifdef WSEVENTLOOP_DEBUG
dbgprintf("Swallow WM_ClientFinishedPaint\n");
#endif
return;
}
}
}
}
if (message->type() == WSMessage::WM_ClientWantsToPaint) {
auto& invalidation_message = static_cast<WSClientWantsToPaintMessage&>(*message);
for (auto& queued_message : m_queued_messages) {
if (receiver == queued_message.receiver && queued_message.message->type() == WSMessage::WM_ClientWantsToPaint) {
auto& queued_invalidation_message = static_cast<WSClientWantsToPaintMessage&>(*queued_message.message);
if (queued_invalidation_message.rect().is_empty() || queued_invalidation_message.rect().contains(invalidation_message.rect())) {
#ifdef WSEVENTLOOP_DEBUG
dbgprintf("Swallow WM_ClientWantsToPaint\n");
#endif
return;
}
}
}
}
#endif
m_queued_messages.append({ receiver, move(message) });
if (current != m_server_process)
m_server_process->request_wakeup();
}
void WSMessageLoop::Timer::reload()
{
struct timeval now;
current->sys$gettimeofday(&now);
gettimeofday(&now, nullptr);
next_fire_time = {
now.tv_sec + (interval / 1000),
now.tv_usec + (interval % 1000)
@ -174,28 +126,22 @@ int WSMessageLoop::stop_timer(int timer_id)
void WSMessageLoop::wait_for_message()
{
fd_set rfds;
memset(&rfds, 0, sizeof(rfds));
auto bitmap = Bitmap::wrap((byte*)&rfds, FD_SETSIZE);
FD_ZERO(&rfds);
int max_fd = 0;
auto add_fd_to_set = [&max_fd] (int fd, auto& bitmap) {
bitmap.set(fd, true);
auto add_fd_to_set = [&max_fd] (int fd, auto& set) {
FD_SET(fd, &set);
if (fd > max_fd)
max_fd = fd;
};
add_fd_to_set(m_keyboard_fd, bitmap);
add_fd_to_set(m_mouse_fd, bitmap);
add_fd_to_set(m_server_fd, bitmap);
add_fd_to_set(m_keyboard_fd, rfds);
add_fd_to_set(m_mouse_fd, rfds);
add_fd_to_set(m_server_fd, rfds);
WSClientConnection::for_each_client([&] (WSClientConnection& client) {
add_fd_to_set(client.fd(), bitmap);
add_fd_to_set(client.fd(), rfds);
});
Syscall::SC_select_params params;
params.nfds = max_fd + 1;
params.readfds = &rfds;
params.writefds = nullptr;
params.exceptfds = nullptr;
struct timeval timeout = { 0, 0 };
bool had_any_timer = false;
@ -210,19 +156,13 @@ void WSMessageLoop::wait_for_message()
timeout = timer.next_fire_time;
}
if (m_timers.is_empty() && m_queued_messages.is_empty())
params.timeout = nullptr;
else
params.timeout = &timeout;
int rc = m_server_process->sys$select(&params);
memory_barrier();
int rc = select(max_fd + 1, &rfds, nullptr, nullptr, m_timers.is_empty() && m_queued_messages.is_empty() ? nullptr : &timeout);
if (rc < 0) {
ASSERT_NOT_REACHED();
}
struct timeval now;
current->sys$gettimeofday(&now);
gettimeofday(&now, nullptr);
for (auto& it : m_timers) {
auto& timer = *it.value;
if (now.tv_sec > timer.next_fire_time.tv_sec || (now.tv_sec == timer.next_fire_time.tv_sec && now.tv_usec > timer.next_fire_time.tv_usec)) {
@ -231,30 +171,37 @@ void WSMessageLoop::wait_for_message()
}
}
if (bitmap.get(m_keyboard_fd))
if (FD_ISSET(m_keyboard_fd, &rfds))
drain_keyboard();
if (bitmap.get(m_mouse_fd))
if (FD_ISSET(m_mouse_fd, &rfds))
drain_mouse();
if (bitmap.get(m_server_fd)) {
if (FD_ISSET(m_server_fd, &rfds)) {
sockaddr_un address;
socklen_t address_size = sizeof(address);
int client_fd = m_server_process->sys$accept(m_server_fd, (sockaddr*)&address, &address_size);
kprintf("accept() returned fd=%d, address=%s\n", client_fd, address.sun_path);
int client_fd = accept(m_server_fd, (sockaddr*)&address, &address_size);
dbgprintf("accept() returned fd=%d, address=%s\n", client_fd, address.sun_path);
ASSERT(client_fd >= 0);
new WSClientConnection(client_fd);
}
WSClientConnection::for_each_client([&] (WSClientConnection& client) {
if (bitmap.get(client.fd())) {
for (;;) {
WSAPI_ClientMessage message;
// FIXME: Don't go one message at a time, that's so much context switching, oof.
ssize_t nread = m_server_process->sys$read(client.fd(), &message, sizeof(WSAPI_ClientMessage));
if (nread == 0)
break;
if (nread < 0) {
ASSERT_NOT_REACHED();
}
on_receive_from_client(client.client_id(), message);
if (!FD_ISSET(client.fd(), &rfds))
return;
unsigned messages_received = 0;
for (;;) {
WSAPI_ClientMessage message;
// FIXME: Don't go one message at a time, that's so much context switching, oof.
ssize_t nread = read(client.fd(), &message, sizeof(WSAPI_ClientMessage));
if (nread == 0) {
if (!messages_received)
notify_client_disconnected(client.client_id());
break;
}
if (nread < 0) {
perror("read");
ASSERT_NOT_REACHED();
}
on_receive_from_client(client.client_id(), message);
++messages_received;
}
});
}
@ -262,14 +209,17 @@ void WSMessageLoop::wait_for_message()
void WSMessageLoop::drain_mouse()
{
auto& screen = WSScreen::the();
auto& mouse = PS2MouseDevice::the();
bool prev_left_button = screen.left_mouse_button_pressed();
bool prev_right_button = screen.right_mouse_button_pressed();
int dx = 0;
int dy = 0;
while (mouse.can_read(*m_server_process)) {
bool left_button = prev_left_button;
bool right_button = prev_right_button;
for (;;) {
byte data[3];
ssize_t nread = mouse.read(*m_server_process, (byte*)data, sizeof(data));
ssize_t nread = read(m_mouse_fd, data, sizeof(data));
if (nread == 0)
break;
ASSERT(nread == sizeof(data));
bool left_button = data[0] & 1;
bool right_button = data[0] & 2;
@ -290,7 +240,7 @@ void WSMessageLoop::drain_mouse()
dx += x;
dy += -y;
if (left_button != prev_left_button || right_button != prev_right_button || !mouse.can_read(*m_server_process)) {
if (left_button != prev_left_button || right_button != prev_right_button) {
prev_left_button = left_button;
prev_right_button = right_button;
screen.on_receive_mouse_data(dx, dy, left_button, right_button);
@ -298,23 +248,26 @@ void WSMessageLoop::drain_mouse()
dy = 0;
}
}
if (dx || dy) {
screen.on_receive_mouse_data(dx, dy, left_button, right_button);
}
}
void WSMessageLoop::drain_keyboard()
{
auto& screen = WSScreen::the();
auto& keyboard = Keyboard::the();
while (keyboard.can_read(*m_server_process)) {
Keyboard::Event event;
ssize_t nread = keyboard.read(*m_server_process, (byte*)&event, sizeof(Keyboard::Event));
ASSERT(nread == sizeof(Keyboard::Event));
for (;;) {
KeyEvent event;
ssize_t nread = read(m_keyboard_fd, (byte*)&event, sizeof(KeyEvent));
if (nread == 0)
break;
ASSERT(nread == sizeof(KeyEvent));
screen.on_receive_keyboard_data(event);
}
}
void WSMessageLoop::notify_client_died(int client_id)
void WSMessageLoop::notify_client_disconnected(int client_id)
{
LOCKER(m_lock);
auto* client = WSClientConnection::from_client_id(client_id);
if (!client)
return;
@ -323,12 +276,14 @@ void WSMessageLoop::notify_client_died(int client_id)
void WSMessageLoop::on_receive_from_client(int client_id, const WSAPI_ClientMessage& message)
{
#if 0
// FIXME: This should not be necessary.. why is this necessary?
while (!running())
Scheduler::yield();
sched_yield();
#endif
LOCKER(m_lock);
WSClientConnection* client = WSClientConnection::ensure_for_client_id(client_id);
WSClientConnection* client = WSClientConnection::from_client_id(client_id);
ASSERT(client);
switch (message.type) {
case WSAPI_ClientMessage::Type::CreateMenubar:
post_message(client, make<WSAPICreateMenubarRequest>(client_id));
@ -383,9 +338,6 @@ void WSMessageLoop::on_receive_from_client(int client_id, const WSAPI_ClientMess
case WSAPI_ClientMessage::Type::GetWindowBackingStore:
post_message(client, make<WSAPIGetWindowBackingStoreRequest>(client_id, message.window_id));
break;
case WSAPI_ClientMessage::Type::ReleaseWindowBackingStore:
post_message(client, make<WSAPIReleaseWindowBackingStoreRequest>(client_id, (int)message.backing.backing_store_id));
break;
case WSAPI_ClientMessage::Type::SetGlobalCursorTracking:
post_message(client, make<WSAPISetGlobalCursorTrackingRequest>(client_id, message.window_id, message.value));
break;

11
WindowServer/WSMessageLoop.h
View file

@ -1,14 +1,12 @@
#pragma once
#include "WSMessage.h"
#include <AK/Lock.h>
#include <AK/HashMap.h>
#include <AK/OwnPtr.h>
#include <AK/Vector.h>
#include <AK/Function.h>
class WSMessageReceiver;
class Process;
struct WSAPI_ClientMessage;
struct WSAPI_ServerMessage;
@ -24,9 +22,6 @@ public:
static WSMessageLoop& the();
bool running() const { return m_running; }
Process& server_process() { return *m_server_process; }
void set_server_process(Process& process) { m_server_process = &process; }
int start_timer(int ms, Function<void()>&&);
int stop_timer(int timer_id);
@ -34,23 +29,19 @@ public:
void post_message_to_client(int client_id, const WSAPI_ServerMessage&);
void on_receive_from_client(int client_id, const WSAPI_ClientMessage&);
static Process* process_from_client_id(int client_id);
void notify_client_died(int client_id);
void notify_client_disconnected(int client_id);
private:
void wait_for_message();
void drain_mouse();
void drain_keyboard();
Lock m_lock;
struct QueuedMessage {
WSMessageReceiver* receiver { nullptr };
OwnPtr<WSMessage> message;
};
Vector<QueuedMessage> m_queued_messages;
Process* m_server_process { nullptr };
bool m_running { false };
int m_keyboard_fd { -1 };

1
WindowServer/WSMessageReceiver.cpp
View file

@ -1,5 +1,4 @@
#include "WSMessageReceiver.h"
#include <AK/Assertions.h>
WSMessageReceiver::WSMessageReceiver()
{

3
WindowServer/WSScreen.cpp
View file

@ -2,7 +2,6 @@
#include "WSMessageLoop.h"
#include "WSMessage.h"
#include "WSWindowManager.h"
#include <AK/Assertions.h>
static WSScreen* s_the;
@ -61,7 +60,7 @@ void WSScreen::on_receive_mouse_data(int dx, int dy, bool left_button, bool righ
WSWindowManager::the().invalidate_cursor();
}
void WSScreen::on_receive_keyboard_data(Keyboard::Event kernel_event)
void WSScreen::on_receive_keyboard_data(KeyEvent kernel_event)
{
auto message = make<WSKeyEvent>(kernel_event.is_press() ? WSMessage::KeyDown : WSMessage::KeyUp, kernel_event.key, kernel_event.character);
message->m_shift = kernel_event.shift();

4
WindowServer/WSScreen.h
View file

@ -3,7 +3,7 @@
#include <SharedGraphics/Rect.h>
#include <SharedGraphics/Size.h>
#include <SharedGraphics/Color.h>
#include <Kernel/Keyboard.h>
#include <Kernel/KeyCode.h>
class WSScreen {
public:
@ -26,7 +26,7 @@ public:
bool right_mouse_button_pressed() const { return m_right_mouse_button_pressed; }
void on_receive_mouse_data(int dx, int dy, bool left_button, bool right_button);
void on_receive_keyboard_data(Keyboard::Event);
void on_receive_keyboard_data(KeyEvent);
protected:
WSScreen(unsigned width, unsigned height);

2
WindowServer/WSWindow.cpp
View file

@ -47,7 +47,7 @@ void WSWindow::set_rect(const Rect& rect)
if (m_menu)
m_backing = GraphicsBitmap::create(m_rect.size());
else if (client)
m_backing = client->create_bitmap(m_rect.size());
m_backing = client->create_shared_bitmap(m_rect.size());
}
WSWindowManager::the().notify_rect_changed(*this, old_rect, rect);

66
WindowServer/WSWindowManager.cpp
View file

@ -2,8 +2,6 @@
#include "WSWindow.h"
#include "WSScreen.h"
#include "WSMessageLoop.h"
#include "Process.h"
#include "MemoryManager.h"
#include <SharedGraphics/Font.h>
#include <SharedGraphics/Painter.h>
#include <SharedGraphics/CharacterBitmap.h>
@ -13,6 +11,9 @@
#include "WSMenuBar.h"
#include "WSMenuItem.h"
#include <WindowServer/WSClientConnection.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdio.h>
#ifdef KERNEL
#include <Kernel/ProcFS.h>
@ -79,8 +80,7 @@ static WSWindowManager* s_the;
WSWindowManager& WSWindowManager::the()
{
if (!s_the)
s_the = new WSWindowManager;
ASSERT(s_the);
return *s_the;
}
@ -130,7 +130,7 @@ void WSWindowManager::flip_buffers()
swap(m_front_painter, m_back_painter);
if (m_framebuffer_fd != -1) {
int new_y_offset = m_buffers_are_flipped ? 0 : m_screen_rect.height();
int rc = current->sys$ioctl(m_framebuffer_fd, 1982, new_y_offset);
int rc = ioctl(m_framebuffer_fd, 1982, new_y_offset);
ASSERT(rc == 0);
}
m_buffers_are_flipped = !m_buffers_are_flipped;
@ -139,9 +139,10 @@ void WSWindowManager::flip_buffers()
WSWindowManager::WSWindowManager()
: m_screen(WSScreen::the())
, m_screen_rect(m_screen.rect())
, m_lock("WSWindowManager")
, m_flash_flush(false)
{
s_the = this;
#ifndef DEBUG_COUNTERS
(void)m_compose_count;
(void)m_flush_count;
@ -172,17 +173,13 @@ WSWindowManager::WSWindowManager()
m_cursor_bitmap_inner = CharacterBitmap::create_from_ascii(cursor_bitmap_inner_ascii, 12, 17);
m_cursor_bitmap_outer = CharacterBitmap::create_from_ascii(cursor_bitmap_outer_ascii, 12, 17);
{
LOCKER(m_wallpaper_path.lock());
m_wallpaper_path.resource() = "/res/wallpapers/cool.rgb";
m_wallpaper = GraphicsBitmap::load_from_file(m_wallpaper_path.resource(), m_screen_rect.size());
}
m_wallpaper_path = "/res/wallpapers/cool.rgb";
m_wallpaper = GraphicsBitmap::load_from_file(m_wallpaper_path, m_screen_rect.size());
#ifdef KERNEL
ProcFS::the().add_sys_bool("wm_flash_flush", m_flash_flush);
ProcFS::the().add_sys_string("wm_wallpaper", m_wallpaper_path, [this] {
LOCKER(m_wallpaper_path.lock());
m_wallpaper = GraphicsBitmap::load_from_file(m_wallpaper_path.resource(), m_screen_rect.size());
m_wallpaper = GraphicsBitmap::load_from_file(m_wallpaper_path, m_screen_rect.size());
invalidate(m_screen_rect);
});
#endif
@ -201,25 +198,31 @@ WSWindowManager::WSWindowManager()
m_system_menu->add_item(make<WSMenuItem>(4, "About..."));
m_system_menu->on_item_activation = [] (WSMenuItem& item) {
if (item.identifier() == 0) {
int error;
Process::create_user_process("/bin/Terminal", 100, 100, 0, error);
if (fork() == 0) {
execl("/bin/Terminal", "/bin/Terminal", nullptr);
ASSERT_NOT_REACHED();
}
return;
}
if (item.identifier() == 4) {
int error;
Process::create_user_process("/bin/About", 100, 100, 0, error);
if (fork() == 0) {
execl("/bin/About", "/bin/About", nullptr);
ASSERT_NOT_REACHED();
}
return;
}
kprintf("WSMenu 1 item activated: '%s'\n", item.text().characters());
dbgprintf("WSMenu 1 item activated: '%s'\n", item.text().characters());
};
}
// NOTE: This ensures that the system menu has the correct dimensions.
set_current_menubar(nullptr);
#if 0
WSMessageLoop::the().start_timer(300, [this] {
invalidate(menubar_rect());
});
#endif
invalidate();
compose();
@ -244,7 +247,6 @@ int WSWindowManager::menubar_menu_margin() const
void WSWindowManager::set_current_menubar(WSMenuBar* menubar)
{
LOCKER(m_lock);
if (menubar)
m_current_menubar = menubar->make_weak_ptr();
else
@ -279,7 +281,6 @@ static const int s_close_button_bitmap_height = 9;
void WSWindowManager::paint_window_frame(WSWindow& window)
{
LOCKER(m_lock);
//printf("[WM] paint_window_frame {%p}, rect: %d,%d %dx%d\n", &window, window.rect().x(), window.rect().y(), window.rect().width(), window.rect().height());
if (window.type() == WSWindowType::Menu) {
@ -357,7 +358,6 @@ void WSWindowManager::paint_window_frame(WSWindow& window)
void WSWindowManager::add_window(WSWindow& window)
{
LOCKER(m_lock);
m_windows.set(&window);
m_windows_in_order.append(&window);
if (!active_window())
@ -366,7 +366,6 @@ void WSWindowManager::add_window(WSWindow& window)
void WSWindowManager::move_to_front(WSWindow& window)
{
LOCKER(m_lock);
if (m_windows_in_order.tail() != &window)
invalidate(window);
m_windows_in_order.remove(&window);
@ -375,7 +374,6 @@ void WSWindowManager::move_to_front(WSWindow& window)
void WSWindowManager::remove_window(WSWindow& window)
{
LOCKER(m_lock);
if (!m_windows.contains(&window))
return;
@ -395,7 +393,6 @@ void WSWindowManager::notify_title_changed(WSWindow& window)
void WSWindowManager::notify_rect_changed(WSWindow& window, const Rect& old_rect, const Rect& new_rect)
{
printf("[WM] WSWindow %p rect changed (%d,%d %dx%d) -> (%d,%d %dx%d)\n", &window, old_rect.x(), old_rect.y(), old_rect.width(), old_rect.height(), new_rect.x(), new_rect.y(), new_rect.width(), new_rect.height());
ASSERT_INTERRUPTS_ENABLED();
invalidate(outer_window_rect(old_rect));
invalidate(outer_window_rect(new_rect));
}
@ -469,7 +466,6 @@ void WSWindowManager::handle_close_button_mouse_event(WSWindow& window, WSMouseE
void WSWindowManager::process_mouse_event(WSMouseEvent& event)
{
LOCKER(m_lock);
if (event.type() == WSMessage::MouseUp && event.button() == MouseButton::Left) {
if (m_drag_window) {
#ifdef DRAG_DEBUG
@ -597,14 +593,12 @@ IterationDecision WSWindowManager::for_each_visible_window_from_front_to_back(Ca
void WSWindowManager::compose()
{
LOCKER(m_lock);
auto dirty_rects = move(m_dirty_rects);
auto cursor_location = m_screen.cursor_location();
dirty_rects.append(m_last_cursor_rect);
dirty_rects.append({ cursor_location.x(), cursor_location.y(), (int)m_cursor_bitmap_inner->width(), (int)m_cursor_bitmap_inner->height() });
#ifdef DEBUG_COUNTERS
dbgprintf("[WM] compose #%u (%u rects)\n", ++m_compose_count, dirty_rects.size());
dbgprintf("kmalloc stats: alloc:%u free:%u eternal:%u\n", sum_alloc, sum_free, kmalloc_sum_eternal);
#endif
auto any_window_contains_rect = [this] (const Rect& r) {
@ -630,7 +624,6 @@ void WSWindowManager::compose()
if (any_window_contains_rect(dirty_rect)) {
continue;
}
LOCKER(m_wallpaper_path.lock());
if (!m_wallpaper)
m_back_painter->fill_rect(dirty_rect, m_background_color);
else
@ -663,7 +656,7 @@ void WSWindowManager::compose()
draw_menubar();
draw_cursor();
if (m_flash_flush.lock_and_copy()) {
if (m_flash_flush) {
for (auto& rect : dirty_rects)
m_front_painter->fill_rect(rect, Color::Yellow);
}
@ -675,7 +668,6 @@ void WSWindowManager::compose()
void WSWindowManager::invalidate_cursor()
{
LOCKER(m_lock);
auto cursor_location = m_screen.cursor_location();
Rect cursor_rect { cursor_location.x(), cursor_location.y(), (int)m_cursor_bitmap_inner->width(), (int)m_cursor_bitmap_inner->height() };
invalidate(cursor_rect);
@ -711,8 +703,6 @@ void WSWindowManager::draw_menubar()
void WSWindowManager::draw_cursor()
{
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
auto cursor_location = m_screen.cursor_location();
Rect cursor_rect { cursor_location.x(), cursor_location.y(), (int)m_cursor_bitmap_inner->width(), (int)m_cursor_bitmap_inner->height() };
Color inner_color = Color::White;
@ -726,8 +716,6 @@ void WSWindowManager::draw_cursor()
void WSWindowManager::on_message(WSMessage& message)
{
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
if (message.is_mouse_event())
return process_mouse_event(static_cast<WSMouseEvent&>(message));
@ -747,7 +735,6 @@ void WSWindowManager::on_message(WSMessage& message)
void WSWindowManager::set_active_window(WSWindow* window)
{
LOCKER(m_lock);
if (window->type() == WSWindowType::Menu) {
dbgprintf("WSWindowManager: Attempted to make a menu window active.\n");
return;
@ -777,14 +764,12 @@ void WSWindowManager::set_active_window(WSWindow* window)
void WSWindowManager::invalidate()
{
LOCKER(m_lock);
m_dirty_rects.clear_with_capacity();
invalidate(m_screen_rect);
}
void WSWindowManager::invalidate(const Rect& a_rect)
{
LOCKER(m_lock);
auto rect = Rect::intersection(a_rect, m_screen_rect);
if (rect.is_empty())
return;
@ -803,7 +788,6 @@ void WSWindowManager::invalidate(const Rect& a_rect)
m_dirty_rects.append(rect);
if (!m_pending_compose_event) {
ASSERT_INTERRUPTS_ENABLED();
WSMessageLoop::the().post_message(this, make<WSMessage>(WSMessage::WM_DeferredCompose));
m_pending_compose_event = true;
}
@ -811,8 +795,6 @@ void WSWindowManager::invalidate(const Rect& a_rect)
void WSWindowManager::invalidate(const WSWindow& window)
{
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
invalidate(outer_window_rect(window.rect()));
}
@ -822,8 +804,6 @@ void WSWindowManager::invalidate(const WSWindow& window, const Rect& rect)
invalidate(window);
return;
}
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
auto outer_rect = outer_window_rect(window.rect());
auto inner_rect = rect;
inner_rect.move_by(window.position());
@ -853,14 +833,12 @@ void WSWindowManager::flush(const Rect& a_rect)
void WSWindowManager::close_menu(WSMenu& menu)
{
LOCKER(m_lock);
if (current_menu() == &menu)
close_current_menu();
}
void WSWindowManager::close_menubar(WSMenuBar& menubar)
{
LOCKER(m_lock);
if (current_menubar() == &menubar)
set_current_menubar(nullptr);
}

14
WindowServer/WSWindowManager.h
View file

@ -6,7 +6,6 @@
#include <AK/HashTable.h>
#include <AK/InlineLinkedList.h>
#include <AK/WeakPtr.h>
#include <AK/Lock.h>
#include <AK/HashMap.h>
#include "WSMessageReceiver.h"
#include "WSMenuBar.h"
@ -27,6 +26,10 @@ enum class IterationDecision { Continue, Abort };
class WSWindowManager : public WSMessageReceiver {
public:
static WSWindowManager& the();
WSWindowManager();
virtual ~WSWindowManager() override;
void add_window(WSWindow&);
void remove_window(WSWindow&);
@ -67,9 +70,6 @@ public:
void set_framebuffer_fd(int fd) { m_framebuffer_fd = fd; }
private:
WSWindowManager();
virtual ~WSWindowManager() override;
void process_mouse_event(WSMouseEvent&);
void handle_menu_mouse_event(WSMenu&, WSMouseEvent&);
void handle_menubar_mouse_event(WSMouseEvent&);
@ -139,12 +139,10 @@ private:
RetainPtr<Font> m_font;
Lockable<String> m_wallpaper_path;
String m_wallpaper_path;
RetainPtr<GraphicsBitmap> m_wallpaper;
mutable Lock m_lock;
Lockable<bool> m_flash_flush;
bool m_flash_flush { false };
bool m_buffers_are_flipped { false };
OwnPtr<WSMenu> m_system_menu;

33
WindowServer/main.cpp
View file

@ -1,19 +1,19 @@
#include "Process.h"
#include <SharedGraphics/Font.h>
#include <WindowServer/WSScreen.h>
#include <WindowServer/WSWindowManager.h>
#include <WindowServer/WSMessageLoop.h>
#include <WindowServer/WSWindow.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
// NOTE: This actually runs as a kernel process.
// I'd like to change this eventually.
void WindowServer_main()
int main(int, char**)
{
WSMessageLoop::the().set_server_process(*current);
current->set_priority(Process::HighPriority);
dbgprintf("WindowServer starting...\n");
WSMessageLoop loop;
int bxvga_fd = current->sys$open("/dev/bxvga", O_RDWR);
int bxvga_fd = open("/dev/bxvga", O_RDWR);
ASSERT(bxvga_fd >= 0);
struct BXVGAResolution {
@ -21,24 +21,17 @@ void WindowServer_main()
int height;
};
BXVGAResolution resolution { 1024, 768 };
int rc = current->sys$ioctl(bxvga_fd, 1985, (int)&resolution);
int rc = ioctl(bxvga_fd, 1985, (int)&resolution);
ASSERT(rc == 0);
Syscall::SC_mmap_params params;
memset(&params, 0, sizeof(params));
params.fd = bxvga_fd;
params.prot = PROT_READ | PROT_WRITE;
params.flags = MAP_SHARED;
params.size = resolution.width * resolution.height * sizeof(RGBA32) * 2;
params.offset = 0;
kprintf("Calling sys$mmap in WS\n");
void* framebuffer = current->sys$mmap(&params);
size_t framebuffer_size_in_bytes = resolution.width * resolution.height * sizeof(RGBA32) * 2;
void* framebuffer = mmap(nullptr, framebuffer_size_in_bytes, PROT_READ | PROT_WRITE, MAP_SHARED, bxvga_fd, 0);
ASSERT(framebuffer && framebuffer != (void*)-1);
WSScreen screen((dword*)framebuffer, resolution.width, resolution.height);
WSWindowManager::the().set_framebuffer_fd(bxvga_fd);
WSWindowManager window_manager;
window_manager.set_framebuffer_fd(bxvga_fd);
dbgprintf("Entering WindowServer main loop.\n");
WSMessageLoop::the().exec();