operating system

39 Articles

Reaching Serenity: Porting Git To A Homebrew Operating System

February 23, 2020 by 6 Comments

Life is all about the little joys — such as waking up in the morning and realizing there’s still plenty of time before you have to actually get up. Or getting up anyway to watch a delightful sunrise as the city slowly wakes up, or as [Andreas Kling] chose, porting your favorite development tool to the operating system you wrote.

With the aesthetics of ’90s UI design and the functionality of a simpler 2000s Unix-style system core in mind, and personal reasons to keep himself busy, [Andreas] started SerenityOS a little while back. Of course, writing your own operating system is always a great educational exercise, but it takes a certain amount of commitment to push it beyond an experimental playground phase. So ideally, you’d eventually want to use it as your actual main system, however, as software developer, [Andreas] was missing one crucial component for that: git. Well, he decided to change that and just port it — and as someone who likes to record his hacking sessions, you can watch him along the way.

Admittedly, watching someone tweaking some build tools and compiler settings would normally sound anything but overly exciting, but it adds a few more layers to it when doing so for a work-in-progress OS written from scratch — from digging into libc implementations to an almost reverse engineering approach to the build environment. If you take pleasure in people’s thought process in problem solving and (spoiler alert) their success, you will enjoy watching [Andreas]. On the other hand, if you’re more curious about a fresh approach at a desktop operating system, SerenityOS itself might be worth looking into. Of course, there are other options for that as well.

Continue reading “Reaching Serenity: Porting Git To A Homebrew Operating System” →

Pack Your Bags – Systemd Is Taking You To A New Home

October 16, 2019 by 177 Comments

Home directories have been a fundamental part on any Unixy system since day one. They’re such a basic element, we usually don’t give them much thought. And why would we? From a low level point of view, whatever location $HOME is pointing to, is a directory just like any other of the countless ones you will find on the system — apart from maybe being located on its own disk partition. Home directories are so unspectacular in their nature, it wouldn’t usually cross anyone’s mind to even consider to change anything about them. And then there’s Lennart Poettering.

In case you’re not familiar with the name, he is the main developer behind the systemd init system, which has nowadays been adopted by the majority of Linux distributions as replacement for its oldschool, Unix-style init-system predecessors, essentially changing everything we knew about the system boot process. Not only did this change personally insult every single Perl-loving, Ken-Thompson-action-figure-owning grey beard, it engendered contempt towards systemd and Lennart himself that approaches Nickelback level. At this point, it probably doesn’t matter anymore what he does next, haters gonna hate. So who better than him to disrupt everything we know about home directories? Where you _live_?

Although, home directories are just one part of the equation that his latest creation — the systemd-homed project — is going to make people hate him even more tackle. The big picture is really more about the whole concept of user management as we know it, which sounds bold and scary, but which in its current state is also a lot more flawed than we might realize. So let’s have a look at what it’s all about, the motivation behind homed, the problems it’s going to both solve and raise, and how it’s maybe time to leave some outdated philosophies behind us.

Continue reading “Pack Your Bags – Systemd Is Taking You To A New Home” →

Bringing PalmOS Back To Life

May 21, 2019 by 36 Comments

Ten years is almost ancient history in the computing world. Going back twelve years is almost unheard of, but that’s about the time that Palm released the last version of their famed PalmOS, an operating system for small, handheld devices that predated Apple’s first smartphone by yet another ten years. As with all pieces of good software there remain devotees, but with something that hasn’t been updated in a decade there’s a lot of work to be done. [Dmitry.GR] set about doing that work, and making a workable Palm device for the modern times.

He goes into incredible detail on this build, but there are some broad takeaways from the project. First, Palm never really released all of the tools that developers would need to build software easily, including documentation of the API system. Since a new device is being constructed, a lot of this needs to be sorted out. Even a kernel was built from scratch for this project, since using a prebuilt one such as Linux was not possible. There were many other pieces of software needed in order to get a working operating system together running on an ARM processor, which he calls rePalm.

There are many other facets of this project that we aren’t able to get into in this limited space, but if you’re at all interested in operating systems or if you fondly remember the pre-smartphone era devices such the various Palm PDAs that were available in the late ’90s and early ’00s, it’s worth taking a look at this one. And if you’d like to see [Dmitry.GR]’s expertise with ARM, he is well-versed.

Thanks to [furre] for the tip!

Grabbing The Thread: Spinlocks Vs Mutexes

March 24, 2019 by 31 Comments

Getting into the weeds of operating systems is daunting work. Especially when the operating system involved is a fully featured modern PC operating system with millions of lines of code all working together to integrate hardware and software seamlessly. One such operating system “weed” is figuring out how to handle simultaneous tasks when the processor can only really handle one thing at time. For that, you’ll be looking at the difference between spinlocks and mutexes.

Both of these are methods of making sure that the processor completes a task sufficiently before moving on to the next task. Modern computers are so fast (even ignoring multiple cores) that it seems as if they are doing many things at once. In order to maintain this illusion, tasks need ways of locking the processor to that specific task for a certain amount of time. Of course the queue for performing the next task can get complicated as there are often many tasks waiting to use processor time. Spinlocks are a simple way of holding the processor and mutexes are a slightly more complicated way, but which one is the most efficient use of system resources isn’t that straightforward.

If you’ve ever been interested in operating system details, this one goes deep into the intricacies of features most of us have never even considered the existence of. It’s definitely worth a read, though, and is very well written by someone who is clearly an expert. If you want an operating system challenge, you can build your own operating system as well.

Pocket Forth Invades Your TI Calculator

January 25, 2019 by 7 Comments

TI certainly have certainly seen off rivals such as HP or Casio to capture the lion’s share of the calculator market. The TI-84 is a real staple, and with as many units as there are out there, hacking them is a given. However, selecting an operating system for the machine can be a hassle. TI-OS is proprietary and doesn’t really want to let you do everything you’d like to. There are alternatives, but many of them won’t let you easily use your calculator to be — well — a calculator.

[Siraben] has zkeme80 which is essentially ANS Forth (mostly) with extensions for the TI hardware. You can easily extend the system, of course, because it is Forth. You can also use the machine for its intended purpose easily.

Continue reading “Pocket Forth Invades Your TI Calculator” →

Roll Your Own Raspberry Pi OS

January 19, 2018 by 27 Comments

Writing an operating system is no small task, but like everything else it is easier than it used to be. [JSandler] has a tutorial on how to create a simple operating system for the Raspberry Pi. One thing that makes it easier is the development environment used. QEMU emulates a Raspberry Pi so you can do the development on a desktop PC and test in the virtual environment. When you are ready, you can set up a bootable SD card and try your work on a real device.

The operating system isn’t very complex, but it does boot, organize memory, displays on the screen, handles interrupts, and manages processes. What else do you need?

Continue reading “Roll Your Own Raspberry Pi OS” →

Forget Troy. Try HelenOS

August 20, 2017 by 17 Comments

Even though it seems like there are a lot of operating system choices, the number narrows if you start counting kernels, instead of distributions. Sure, Windows is clearly an operating system family, and on the Unix-like side, there is Linux and BSD. But many other operating systems–Ubuntu, Fedora, Raspian–they all derive from some stock operating system. There are some outliers, though, and one of those is HelenOS. The open source OS runs on many platforms, including PCs, Raspberry PIs, Beaglebones, and many others.

Although the OS isn’t new, it is gaining more features and is now at version 0.7. You can see a video about some of the new features, below.

According to the project’s web site:

HelenOS is a portable microkernel-based multiserver operating system designed and implemented from scratch. It decomposes key operating system functionality such as file systems, networking, device drivers and graphical user interface into a collection of fine-grained user space components that interact with each other via message passing. A failure or crash of one component does not directly harm others. HelenOS is therefore flexible, modular, extensible, fault tolerant and easy to understand.

Continue reading “Forget Troy. Try HelenOS” →