Linux 3.8 Release

Linus Torvalds has announced the release of Linux Kernel 3.8:

The release got delayed a couple of days because I was waiting for confirmation of a small patch, but hey, we could also say that it was all intentional, and that this is the special “Presidents’ Day Release”. It sounds more planned that way, no?

Anyway, the really good news is that things calmed down a lot on the last week. There are noticeably fewer commits, and they are also all quite small. The few commits with more than just a couple of lines tend to be due to a couple of reverts, and two architecture patches where some identifiers got renamed (tile), or some defines got moved from the uapi file to a private header (x86). And there’s one radeon patch that uses a helper function instead of reading bytes directly.

And even those “bigger” patches weren’t really that big.

There was a pending btrfs fix that might have merited another -rc, but instead of delaying things I just didn’t pull that one at all, and we’ll just do it as a stable patch instead. It’s not even a new problem anyway.

Anyway, thanks to everybody who kept last week calm.

Linux 3.7 brought ARM multi-platform (aka Unified ARM kernel), and ARM 64-bit (ARMv8 / Aarch64) support, some btrfs improvements, introduced signed kernel modules capability, NFS 4.1 left “experimental feature” stage , SMBv2 experimental was added, and some network improvements were implemented.

Linux 3.8 brings the following key changes:

  • Ext4 embeds very small files in the inode (inline data support) – The inodes are used to store various information (size, date creation, owner, etc) about files, each inode size is predetermined during ext4 format (default: 256 bytes), and the inode is not always fully utilized and at least one data block is always allocated for file data (usually 4KB) even if the file only uses a few bytes. That’s why Ext4 has added support for storing very small files in the unused inode space in order to save space and improve performance. Some simple tests have shown that this implementation can save between around 1% to 3% of space. For small files performance gains can be substantial. Read Improving ext4: bigalloc, inline data, and metadata checksums for details.
  • Btrfs fast device replacement – Btrfs can expand to multiple devices, and allows to hot plug/remove disks. The speed of the process has now been using a device replacement operation: “btrfs replace mountpoint old_disk new_disk”. This operation does not require to unmount or stop current tasks, and is safe to use even in case of crash or power failure. “btrfs replace status” checks the status of the operation, and “btrfs replace cancel” cancels it.
  • F2FS, a SSD friendly filesystem – F2FS is a new experimental filesystem optimized for flash memory storage devices. Contrary to file systems such as jffs2 and ubifs, that are designed for “native” flash devices that expose the flash storage device directly to the computer, F2FS is designed for flash storage devices that come with a FTL (“flash translation layer”) such as SSDs. The code can be found in fs/f2fs.  To find out more you can read a summary of and/or watch F2FS – A New Flash File System for Mobile Devices presentation at ELCE 2012.
  • User namespace support completed – This release adds is the ability for unprivileged users to use per-process namespaces safely. The resources with namespace support available are filesystem mount points, UTS, IPC, PIDs, and network stack. To find out more your can read a few namespace articles from LWM: namespaces overview, the namespaces APIPID namespaces, and more on PID namespaces.
  • Huge Pages support a zero page – Huge pages are a type of memory pages provided by the CPU memory management unit, which are much bigger than usual. They are typically used by big databases and applications which maker use of large portions of memory. In the other hand, a “zero page” is a memory page full of zeros. This page is used by the kernel to save memory: some applications allocate large portions of memory full of zeros but they don’t write to all parts of it, so instead of allocating that zeroed memory, the kernel just makes all the memory point to the zero page. The zero page was only available for normal sized pages (4KB in x86), this release adds a zero huge page for applications that use huge pages. You may want to read Adding a huge zero page for details.
  • The memory resource controller supports accounting of kernel memory – The Linux memory controller is a control group that can limit, account and isolate memory usage to arbitrary groups of processes. In this release, the memory controller has got support for accounting two types uses of kernel memory usage: stack and slab usage. These limits can be useful for things like stopping fork bombs. To learn more read KS2012: memcg/mm: Improving kernel-memory accounting for memory cgroups.
  • Automatic NUMA balancing – A lot of modern machines are “non uniform memory access” (NUMA) architectures: they have per-processor memory controllers, and accessing the memory in the local processor is faster than accessing the memory of other processors. This release includes a new NUMA foundation which will allow to build smarter NUMA policies in the next releases.
  • Bye bye 386 processors –  Linux 3.8 no longer supports Intel 386 processors.

Further details on Linux 3.8 are available on

Share this:
FacebookTwitterHacker NewsSlashdotRedditLinkedInPinterestFlipboardMeWeLineEmailShare

Support CNX Software! Donate via cryptocurrencies, become a Patron on Patreon, or purchase goods on Amazon or Aliexpress

ROCK Pi 4C Plus

Leave a Reply

Your email address will not be published. Required fields are marked *

Khadas VIM4 SBC
Khadas VIM4 SBC