Flipped Bit Could Mark The End Of Voyager 1‘s Interstellar Mission

Sometimes it’s hard to read the tea leaves of what’s going on with high-profile space missions. Weighted down as they are with the need to be careful with taxpayer money and having so much national prestige on the line, space agencies are usually pretty cagey about what’s going on up there. But when project managers talk about needing a “miracle” to continue a project, you know things have gotten serious.

And so things now sit with Voyager 1, humanity’s most distant scientific outpost, currently careening away from Mother Earth at 17 kilometers every second and unable to transmit useful scientific or engineering data back to us across nearly a light-day of space. The problem with the 46-year-old spacecraft cropped up back in November, when Voyager started sending gibberish back to Earth. NASA publicly discussed the problem in December, initially blaming it on the telemetry modulation unit (TMU) that packages data from the remaining operable scientific instruments along with engineering data for transmission back to Earth. It appeared at the time that the TMU was not properly communicating with the flight data system (FDS), the main flight computer aboard the spacecraft.

Since then, flight controllers have determined that the problem lies within the one remaining FDS on board (the backup FDS failed back in 1981), most likely thanks to a single bit of corrupted memory. The Deep Space Network is still receiving carrier signals from Voyager, meaning its 3.7-meter high-gain antenna is still pointing back at Earth, so that’s encouraging. But with the corrupt memory, they’ve got no engineering data from the spacecraft to confirm their hypothesis.

The team has tried rebooting the FDS, to no avail. They’re currently evaluating a plan to send commands to put the spacecraft into a flight mode last used during its planetary fly-bys, in the hope that will yield some clues about where the memory is corrupted, if indeed it is. But without a simulator to test the changes, and with most of the engineers who originally built the spacecraft long gone now, the team is treading very carefully.

Voyager 1 is long past warranty, of course, and with an unparalleled record of discovery, it doesn’t owe us anything at this point. But we’re not quite ready to see it slip into its long interstellar sleep, and we wish the team good luck while it works through the issue.

Laptop Memory Upgradable Again

For some computing components, the bottleneck to improved speed and performance hasn’t been power consumption or clock speed but physical space. But a new memory standard may provide all of the power and space-saving benefits of soldered memory modules without losing any upgradability.

The standard is called compression attached memory modules (CAMM) and provides a way for small form factor computers to have upgradable memory without needing dual in-line memory module (DIMM) slots. Unlike DIMM, though, CAMM modules allow for modern high-speed low-power memory to be used and can take advantage of dual-channel properties even if only one memory module is installed. CAMM modules are held in place with small screws, similar to modern M.2 drives, and don’t have the massive footprint of a DIMM slot. This allows laptop manufacturers to save nearly as much space as having soldered memory.

While this won’t solve the problem of computer manufacturers offering only soldered memory as a cash-grab, hopefully, some take the new standard under their wing for those of us who value the upgradability of our hardware. There are of course some problems with newer standards, but right now it seems like the only other viable option is soldered modules or slower, heavier computers. Some may argue that these soldered-on modules can be upgraded in theory, but not without considerable effort.

Some Bacteria Could Have A Rudimentary Form Of Memory

When we think of bacteria, we think of simple single-celled organisms that basically exist to consume resources and reproduce. They don’t think, feel, or remember… or do they? Bacteria don’t have brains, and as far as we know, they’re incapable of thought. But could they react to an experience and recall it later?

New research suggests that some bacteria could have a rudimentary form of memory of their experiences in the environment. They could even pass this memory down across generations via a unique mechanism. Let’s dive into the latest research that is investigating just what bacteria know, and how they happen to know it.

Continue reading “Some Bacteria Could Have A Rudimentary Form Of Memory”

Error-Correcting RAM On The Desktop

When running a server, especially one with mission-critical applications, it’s common practice to use error-correcting code (ECC) memory. As the name suggests, it uses an error-correcting algorithm to continually check for and fix certain errors in memory. We don’t often see these memory modules on the desktop for plenty of reasons, among which are increased cost and overhead and decreased performance for only marginal gains, but if your data is of upmost importance even when working on a desktop machine, it is possible to get these modules up and running in certain modern AMD computers.

Specifically, this feature was available on AMD Ryzen CPUs, but since the 7000 series with the AM5 socket launched, the feature wasn’t officially supported anymore. [Rain] decided to upgrade their computer anyway, but there were some rumors floating around the Internet that this feature might still be functional. An upgrade to the new motherboard’s UEFI was required, as well as some tweaks to the Linux kernel to make sure there was support for these memory modules. After probing the system’s behavior, it is verified that the ECC RAM is working and properly reporting errors to the operating system.

Reporting to the OS and enabling the correct modules is one thing, actually correcting an error was another. It turns out that introducing errors manually and letting the memory correct them is possible as well, and [Rain] was able to perform this check during this process as well. While ECC RAM may be considered overkill for most desktop users, it offers valuable data integrity for professional or work-related tasks. Just don’t use it for your Super Mario 64 speedruns.

A Mainframe Computer For The Modern Age

The era of mainframe computers and directly programming machines with switches is long past, but plenty of us look back on that era with a certain nostalgia. Getting that close to the hardware and knowing precisely what’s going on is becoming a little bit of a lost art. That’s why [Phil] took it upon himself to build this homage to the mainframe computer of the 70s, which all but disappeared when PCs and microcontrollers took over the scene decades ago.

The machine, known as PlasMa, is not a recreation of any specific computer but instead looks to recreate the feel of computers of this era in a more manageable size. [Phil] built the entire machine from scratch, and it can be programmed directly using toggle switches to input values into registers and memory. Programs can be run or single-stepped, and breakpoints can be set for debugging. The internal workings of the machine, including the program counter, instruction register, accumulator, and work registers, are visible in binary lights. Front panel switches let you control those same items.

The computer also hosts three different microcodes, each providing a unique instruction set. Two are based on computers from Princeton, Toy-A, and Toy-B, used as teaching tools. The third is a more advanced instruction set that allows using things like emulated peripherals, including storage devices. If you want to build one or just follow along as the machine is constructed, programmed, and used, [Phil] has a series of videos demonstrating its functionality, and he’s made everything open-source for those more curious. It’s a great way to get a grasp on the fundamentals of computing, and the only way we could think of to get even more into the inner workings of a machine like this is to build something like a relay computer.

Continue reading “A Mainframe Computer For The Modern Age”

Exploring The Anatomy Of A Linux Kernel Exploit

A lot of talk and discussion happens anytime a hardware manufacturer releases a new line of faster, more powerful, or more efficient computers. It’s easy to see better and better specifications and assume that’s where all the progress is made. But without improved software and algorithms, often the full potential of the hardware can’t be realized. That’s the reason for the creation of io_uring, an improved system call interface in the Linux kernel. It’s also where [chompie] went to look for exploits.

The reason for looking here, in a part of the kernel [chompie] had only recently learned about, was twofold. First, because it’s a place where user space applications interact with the kernel, and second because it’s relatively new and that means more opportunities to find bugs. The exploit involves taking advantage of a complicated asynchronous buffer system, specifically at a location where the code confuses a memory location being used by the kernel with one which is supposed to be used for user space.

To actually get this to work as an exploit, though, a much more involved process is needed to make sure the manipulation of these memory addresses results in something actually useful, but it is eventually used to gain local privilege escalation. More about it can be found in this bug report as well. Thanks to the fact that Linux is open-source, this bug can quickly be fixed and the patch rolled out to prevent malicious attackers from exploiting it. Open-source software has plenty of other benefits besides being inherently more secure, though.

Increasing System Memory With The Flick Of A Switch

There’s an apocryphal quote floating around the internet that “640K ought to be enough memory for anybody” but it does seem unlikely that this was ever actually said by any famous computer moguls of the 1980s. What is true, however, is that in general more computer memory tends to be better than less. In fact, this was the basis for the Macintosh 512k in the 1980s, whose main feature was that it was essentially the same machine as the Macintosh 128k, but with quadruple the memory as its predecessor. If you have yet to upgrade to the 512k, though, it might be best to take a look at this memory upgrade instead.

The Fat Mac Switcher, as it is called by its creator [Kay Koba], can upgrade the memory capability of these retro Apple machines with the simple push of a switch. The switch and controller logic sit on a separate PCB that needs to be installed into the computer’s motherboard in place of some of the existing circuitry. The computer itself needs its 16 memory modules replaced with 41256 DRAM modules for this to work properly though, but once its installed it can switch seamlessly between 512k and 128k modes.

Another interesting quirk of the retro Macintosh scene is that the technically inferior 128k models tend to be valued higher than the more capable 512k versions, despite being nearly identical otherwise. There are also some other interesting discussions on one of the forum posts about this build as well. This module can also be used in reverse; by installing it in a Macintosh 512k the computer can be downgraded to the original Macintosh 128k. For this the memory modules won’t need to be upgraded but a different change to the motherboard is required.

A product like this certainly would have been a welcome addition in the mid 80s when these machines were first introduced, since the 512k was released only months after the 128k machines were, but the retrocomputing enthusiasts should still get some use out of this device and be more able to explore the differences between the two computers. If you never were able to experience one of these “original” Macintosh computers in their heyday, check out this fully-functional one-third scale replica.