It appears that the primary cause of GCC slowness is malloc() slowness. So we need a faster malloc(). Let's write one.

Especially noticeable with Terminal:

Just hold down the logo button and right-click-drag in the top left corner of a terminal to experience the jankery.

Perhaps a crash handler daemon could be notified when a process crashes, and symbolicate the backtrace somehow?
We would need a few things to be able to build this:

• A userspace flavor of the ELF loader code. This will be needed eventually anyway when implementing dynamic linking.
• Some kind of notification system to let us know there was a crash
• Some way for the crash handler to remotely inspect the stack of the crashed process
• Some way for the crash handler to dump the memory map of the crashed process

It would be good to support dynamic linking so we don't have to relink everything whenever libc changes.

We should have a utmp file that tell us who's logged in to the system.
It should be updated on login/logout, and we should have a "w" and maybe a "who" program to show what's in the file.

We could also have a wtmp file with historical utmp records, and a "last" program to dump it.

After building Serenity with this command:

(export LC_ALL=en_US.UTF-8; cd Toolchain && ./BuildIt.sh && source ./UseIt.sh && cd ../Kernel && ./makeall.sh)

I am trying to run it:

Kernel/run

Which gives this error message:

qemu-system-i386: -hda _fs_contents: Could not open '_fs_contents': No such file or directory

Entering the Kernel directory manually and running run, results in this error message:

WARNING: Image format was not specified for '_fs_contents' and probing guessed raw.
Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.
Specify the 'raw' format explicitly to remove the restrictions.
CPU Reset (CPU 0)
EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000
ESI=00000000 EDI=00000000 EBP=00000000 ESP=00000000
EIP=00000000 EFL=00000000 [-------] CPL=0 II=0 A20=0 SMM=0 HLT=0
ES =0000 00000000 00000000 00000000
CS =0000 00000000 00000000 00000000
SS =0000 00000000 00000000 00000000
DS =0000 00000000 00000000 00000000
FS =0000 00000000 00000000 00000000
GS =0000 00000000 00000000 00000000
LDT=0000 00000000 00000000 00000000
TR =0000 00000000 00000000 00000000
GDT=     00000000 00000000
IDT=     00000000 00000000
CR0=00000000 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=00000000 DR7=00000000
CCS=00000000 CCD=00000000 CCO=DYNAMIC
EFER=0000000000000000
FCW=0000 FSW=0000 [ST=0] FTW=ff MXCSR=00000000
FPR0=0000000000000000 0000 FPR1=0000000000000000 0000
FPR2=0000000000000000 0000 FPR3=0000000000000000 0000
FPR4=0000000000000000 0000 FPR5=0000000000000000 0000
FPR6=0000000000000000 0000 FPR7=0000000000000000 0000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000
qemu-system-i386: Initialization of device ide-hd failed: Could not reopen file: Permission denied

This is with qemu version 4.0.0.

RangeAllocator::deallocate() should put incoming ranges at the right place immediately instead of requiring a separate sorting pass.

First off, it would be good to have setenv().
Also, putenv() should put the passed string into the environment without copying, so altering the string later on would actually alter the environment.

We should pad VM allocations with at least one unmapped page on each side of the range. This will provide basic protection against buffer/stack overflows.

We should have a /bin/pidof that prints the PID of a program based on a string.

Im trying to compile Lua and got stuck.Here is what i did.

I changed CC=gcc to CC= i686-pc-serenity-gcc -std=gnu99 in /lua/src/Makefile

cd /lib/gcc/i686-pc-serenity/8.3.0/include/readline
mkdir readline
sudo cp /usr/include/readline/* . //install libreadline for serenity gcc

cd /home/mustafa/src/lua/src/
make linux // i guess this is correct option?

At this point compilations fails with this error

make all SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline" 
make[1]: Entering directory '/home/mustafa/src/lua/src' 
i686-pc-serenity-gcc -std=gnu99 -o lua   lua.o liblua.a -lm -Wl,-E -ldl -lreadline
/opt/cross/lib/gcc/i686-pc-serenity/8.3.0/../../../../i686-pc-serenity/bin/ld: cannot find -ldl 
/opt/cross/lib/gcc/i686-pc-serenity/8.3.0/../../../../i686-pc-serenity/bin/ld: cannot find -lreadline
collect2: error: ld returned 1 exit status
Makefile:63: recipe for target 'lua' failed 
make[1]: *** [lua] Error 1
make[1]: Leaving directory '/home/mustafa/src/lua/src'
Makefile:110: recipe for target 'linux' failed
make: *** [linux] Error 2

When cloning the serenity repo and running this command:

(export LC_ALL=en_US.UTF-8; cd Toolchain; ./BuildIt.sh; chmod +x UseIt.sh; ./UseIt.sh; cd ../Kernel; ./makeall.sh) 1> output.log 2> error.log

These errors appears:

/bin/sh: i686-pc-serenity-g++: command not found
/bin/sh: i686-pc-serenity-g++: command not found
/bin/sh: i686-pc-serenity-g++: command not found
make: *** [Makefile:69: ../AK/StringImpl.o] Error 127
make: *** Waiting for unfinished jobs....
make: *** [Makefile:69: ../AK/String.o] Error 127
/bin/sh: i686-pc-serenity-g++: command not found
make: *** [Makefile:69: ../AK/StringView.o] Error 127
/bin/sh: i686-pc-serenity-g++: command not found
make: *** [Makefile:69: ../AK/StringBuilder.o] Error 127
make: *** [Makefile:69: ../AK/FileSystemPath.o] Error 127
/bin/sh: i686-pc-serenity-g++: command not found
/bin/sh: i686-pc-serenity-g++: command not found
make: *** [Makefile:69: ../AK/MappedFile.o] Error 127
make: *** [Makefile:69: ../AK/StdLibExtras.o] Error 127
/bin/sh: i686-pc-serenity-g++: command not found
make: *** [Makefile:69: SharedBuffer.o] Error 127

Attaching output.log and error.log.

This is on Arch Linux, x86, 64-bit, with gcc 8.3.0.

output.log
error.log

We should have a /bin/killall that sends a given signal to every process with a certain name.

I guess this might mean another concept rather than just activation. Perhaps selection (single click, arrows) vs activation (double click/enter key)? Either way, it would make it much nicer to use.

The GTextEditor widget should optionally support line wrapping (word-wrap).

When I try to click&drag anything with the mouse, it basically doesn't work most of the time, misinterpreted it as clicks the other 5%, and the last 1% of the time it actually works. I'm not really sure how we would go about fixing this, but I have two guesses as to what's wrong:

1. the heuristics for what's a click vs whats a drag need tweaking
2. my VM is broken in some way.

I cloned, built, and ran SerenityOS this morning and it doesn't seem to be able to connect to the internet correctly. If I run ping 127.0.0.1 (localhost) it works, but if I try ping 8.8.8.8 the request times out and if I attempt ping google.com it tells me that the lookup failed:

I'm not sure what I need to do at this point, I'm assuming its a problem with setting up QEMU? Also, this brings up another thing, when the IRC client can't connect to the internet it just freezes the entire OS, so that's something that needs to be fixed:

I planned on contributing to the userland of this OS at first (maybe starting with getting the FileManager forward/back arrows to work: #36, or getting the ProcessManager tree view #65) and then working up to maybe contributing to the more lower level stuff. So if there's something that needs to be fixed here I'd like to help.

It would be cool to be able to see the process table as a tree.

I'm not sure where else to ask this, but I'm working on making a config file for the Launcher app, so you can tell it what applications it should show, and their associated icons (instead of hardcoding it), and whether to run them straight (as a GUI app) or through a terminal. However, before I get started on this, we obviously need to know, what the config format should be.

I'm also going to work on a settings manager next, so that also should use whatever config format we decide on. And if we decide on something general enough, we could use it for the UI builder too.

A Region is meant to function as a "view" onto a VMObject, but because it currently retains the entire VMObject, it effectively causes all of the VMObject's physical pages to be retained for the lifetime of the Region.

This means that a small Region can end up retaining a huge number of physical pages, as long as they were at some point mapped into the VMObject.

As you may know no operating system is a real system without having a port of Doom running on it.

I think the easiest way to achieve this would be to port PrBoom and its only dependency, SDL 1.2. This engine only requires working video and input backend from SDL, having the other audio, networking, etc. backends are not a hard requirement.

PrBoom website: http://prboom.sourceforge.net/
SDL 1.2: https://www.libsdl.org/download-1.2.php

Also I've worked on porting Doom for Redox in the past. You may want to take a look at how we patched SDL to add a new backend for our Orbital display server. Could help bringing SDL to Serenity: https://gitlab.redox-os.org/redox-os/cookbook/tree/master/recipes/sdl

We need sometimes to use paths like /proc/all (see source code of pidof, killall...).
It would be nice to make a helper function that everyone can use instead of manually using it everywhere.

This helper could be used to retrieve a String or directly a CFile.

Currently it's only possible to see processes.
It would be cool to be able to see threads, perhaps as "tree children" of processes, or maybe just as a thread count column. But somehow.

If calling GMenu::popup() at the bottom right corner of the screen, it should anchor the menus lower right corner to the lower right corner of the screen, etc.

They should be bumped so they are completely inside the screen rect

We should have a way to make a window fullscreen.
And I suppose also a way to keep it on top of every other window.

Hi there, I'm interested in this project so I tried building it. I tried on Manjaro, a Ubuntu 18.10 virtual machine, and an Ubuntu 18.04.2 Windows subsystem. I'm probably just missing a dependency but maybe the script can be altered to check for that? The error I get on all operating systems:

make[2]: Entering directory '/home/wdd/serenity/Toolchain/Build/gcc/i686-pc-serenity/libgcc'
if [ -z "" ]; then \
  true; \
else \
  rootpre=`${PWDCMD-pwd}`/; export rootpre; \
  srcrootpre=`cd /home/wdd/serenity/Toolchain/Tarballs/gcc-8.3.0/libgcc; ${PWDCMD-pwd}`/; export srcrootpre; \
  lib=`echo "${rootpre}" | sed -e 's,^.*/\([^/][^/]*\)/$,\1,'`; \
  compiler="/home/wdd/serenity/Toolchain/Build/gcc/./gcc/xgcc -B/home/wdd/serenity/Toolchain/Build/gcc/./gcc/ -B/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/bin/ -B/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/lib/ -isystem /home/wdd/serenity/Toolchain/Local/i686-pc-serenity/include -isystem /home/wdd/serenity/Toolchain/Local/i686-pc-serenity/sys-include   "; \
  for i in `${compiler} --print-multi-lib 2>/dev/null`; do \
    dir=`echo $i | sed -e 's/;.*$//'`; \
    if [ "${dir}" = "." ]; then \
      true; \
    else \
      if [ -d ../${dir}/${lib} ]; then \
	flags=`echo $i | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`; \
	if (cd ../${dir}/${lib}; make "AR=/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/bin/ar" "AR_FLAGS=rc" "CC=/home/wdd/serenity/Toolchain/Build/gcc/./gcc/xgcc -B/home/wdd/serenity/Toolchain/Build/gcc/./gcc/ -B/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/bin/ -B/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/lib/ -isystem /home/wdd/serenity/Toolchain/Local/i686-pc-serenity/include -isystem /home/wdd/serenity/Toolchain/Local/i686-pc-serenity/sys-include   " "CFLAGS=-g -O2" "DESTDIR=" "EXTRA_OFILES=" "HDEFINES=" "INSTALL=/usr/bin/install -c" "INSTALL_DATA=/usr/bin/install -c -m 644" "INSTALL_PROGRAM=/usr/bin/install -c" "LDFLAGS=" "LOADLIBES=" "RANLIB=/home/wdd/serenity/Toolchain/Local/i686-pc-serenity/bin/ranlib" "SHELL=/bin/bash" "prefix=/home/wdd/serenity/Toolchain/Local" "exec_prefix=/home/wdd/serenity/Toolchain/Local" "libdir=/home/wdd/serenity/Toolchain/Local/lib" "libsubdir=/home/wdd/serenity/Toolchain/Local/lib/gcc/i686-pc-serenity/8.3.0" "tooldir=/home/wdd/serenity/Toolchain/Local/i686-pc-serenity" \
			CFLAGS="-g -O2 ${flags}" \
			CCASFLAGS=" ${flags}" \
			FCFLAGS=" ${flags}" \
			FFLAGS=" ${flags}" \
			ADAFLAGS=" ${flags}" \
			prefix="/home/wdd/serenity/Toolchain/Local" \
			exec_prefix="/home/wdd/serenity/Toolchain/Local" \
			GOCFLAGS="-O2 -g ${flags}" \
			CXXFLAGS="-g -O2 ${flags}" \
			LIBCFLAGS="-g -O2 ${flags}" \
			LIBCXXFLAGS="-g -O2 -fno-implicit-templates ${flags}" \
			LDFLAGS=" ${flags}" \
			MULTIFLAGS="${flags}" \
			DESTDIR="" \
			INSTALL="/usr/bin/install -c" \
			INSTALL_DATA="/usr/bin/install -c -m 644" \
			INSTALL_PROGRAM="/usr/bin/install -c" \
			INSTALL_SCRIPT="/usr/bin/install -c" \
			install); then \
	  true; \
	else \
	  exit 1; \
	fi; \
      else true; \
      fi; \
    fi; \
  done; \
fi
make[2]: Leaving directory '/home/wdd/serenity/Toolchain/Build/gcc/i686-pc-serenity/libgcc'
make[1]: Leaving directory '/home/wdd/serenity/Toolchain/Build/gcc/i686-pc-serenity/libgcc'
make[1]: Entering directory '/home/wdd/serenity/Toolchain/Build/gcc/i686-pc-serenity/libstdc++-v3'
make[1]: *** No rule to make target 'install'.  Stop.
make[1]: Leaving directory '/home/wdd/serenity/Toolchain/Build/gcc/i686-pc-serenity/libstdc++-v3'
make: *** [Makefile:10958: install-target-libstdc++-v3] Error 2
~/serenity/Toolchain/Build ~/serenity/Toolchain
~/serenity/Toolchain
wdd@webVM:~/serenity/Toolchain$ 

Sorry to bother, I hope to contribute at some point after my exams!

There's a strip of white where there shouldn't be when rendering a long line with the cursor on it.

For example, when trying to recvfrom() on a disconnected TCP socket.

See #80 for context.

The scanf() family of functions in LibC/scanf.cpp should be rewritten, since they are borrowed from an outside source.
The current version doesn't always work correctly, so there's good reason beyond just NIH.

The FileManager should remember our movements in the file system and the arrows should allow us to go back and forward.

Both the client and server side assumes that the extra data packet is immediately available, or they will crash. If an API message has non-zero extra_size, we need to block until that data is also available.

Hi,

I just git cloned the latest master, entered the Toolchain directory and went:

./BuildIt.sh

The last lines of the output were:

CXX sys/socket.cpp
CXX sys/wait.cpp
CXX sys/uio.cpp
CXX poll.cpp
CXX locale.cpp
locale.cpp:11:1: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
};
^
locale.cpp:11:1: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
locale.cpp:11:1: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
CXX arpa/inet.cpp
CXX netdb.cpp
CXX sched.cpp
AS setjmp.ao
AS crti.ao
AS crtn.ao
LIB libc.a
mkdir -p ../Root/usr/include
mkdir -p ../Root/usr/lib
# Copy headers
rsync -r -a --include '*/' --include '*.h' --exclude '*' . ../Root/usr/include
# Install the library
cp libc.a ../Root/usr/lib
cp crt0.o ../Root/usr/lib/
cp: klarte ikke å hente informasjon om 'crt0.o': Ingen slik fil eller filkatalog
make: *** [Makefile:86: install] Error 1
make: Leaving directory '/home/afr/clones/serenity/LibC'

"Ingen slik fil eller filkatalog" means "No such file or directory" in Norwegian.

Using export LC_ALL=C or export LC_ALL=en_US.UTF-8 in the build script will produce error messages in English instead of the local preference.

I am unable to see, at a glance, why it can't find crt0.o.

This is with gcc 8.3.0 on 64-bit x86.

Thanks for creating an alternative operating system! I'm looking forward to trying it out one day.

Here is my idea for an incrementaly build the application for serenity

Each app will have a manifest file (maybe .ini for the win9X feel 😉 )

For exemple the manifest.ini for VisualBuilder would be:

[Application]
Name="Visual Builder"
Description="A familiar GUI building tool"
Author="awesomekling"
License="2-clause BSD license."
Version="0.1.0-beta"

[Install]
Path="/opt/VisualBuilder/vb"
MakeDesktopFile=true

[Build]
OLevel=3
Defines="DEBUG"

[Dependancies]
LibC=true
LibGUI=true

Then a python script or whatever would parse the manifest and make sure all the dependencies are up-to-date and then build the application if needed.

Also we can generate desktop like file for a futur start menu or whatever

I already build something like this for my own hobby operating system project, so i can just cleanup the code, refactor bit and make a port for serenity.

What do you think?

WSWindowManager currently handles both window compositing, and general window management.

It would be good to separate these things, especially if we would like to have out-of-process window management in the future.

Terminal should have a scrollback history buffer so we can see what happened when something generates lots of output.

This will probably require doing some eager save/restore somewhere. I haven't looked closely at it.

We don't know what's happening yet, but not calling dump_backtrace() avoids triple faulting.
This seems to happen somewhere in the ELF symbolication code.

Undecided. Probably something close to 2-clause BSD.

If you are using GPL code you can't just relicence them as BSD, see elf.h .

Easy repro: Try to open /proc/self

Alpha blending is currently pretty slow. It could be faster if it were written with SIMD.

Unix-like systems typically don't allow non-root users to bind to TCP/UDP ports < 1024.

We're currently using a borrowed qsort() from some BSD. We should have our own.

We should have a /bin/tail program that supports -f for log monitoring.

Some observations for DNS ;)

• Randomize ids in get_next_id
• Consider using 0x20 randomization for hostnames
• Check if question received matched the one sent.
• Truncation support and retry through TCP (or TLS?)
• A cache/TTL implementation?

We're currently using a getopt() borrowed from some BSD. It should be replaced with our own.

Right now we only support negative timeout for indefinite blocking.
poll() should piggyback on the select() timeout mechanism.

Meybe using other project source code? gui matchbox or haikuos gui
similar https://github.com/Barrett17/V-OS

How fast are for example ruby vs linux Ruby?

Currently the Process::m_range_allocator is cleared on fork() and inherited on exec() which is backwards.
This is causing /bin/su to crash.