Linux Kernel 6.14 Features and Release Date: Best Intro

In this article from Orcacore, we will bring you some interesting content about Linux Kernel 6.14 Features and Release date. About two weeks ago, Linus Torvalds shared some exciting news about the first release candidate (RC) for the Linux kernel 6.14 series, which is now available for public testing. Now it’s time for Linux fans to start testing the weekly Release Candidate builds. Because the final release of Linux kernel 6.14 is about two months away.

Key Features and Improvements of Linux Kernel 6.14

First, let’s take a look at some of the new Linux Kernel 6.14 Features.

The first thing to note is that the Linux kernel 6.14 series has several notable additions. These include:

• Rust integration improvements.
• LoongArch KVM Hypervisor support.
• PCI error recovery mechanism for IBM System/390.
• Raspberry Pi PM suspend/resume support.
• Dell XPS 9370 manual fan control.
• Updated drivers for improved hardware compatibility.
• Networking improvements for IPsec and large packet transmission.
• ALSA APIs improvement for MIDI 2.0.

This is a big step towards building a stable kernel with Rust features exclusively. In previous releases, we were limited to unstable features. Now, as per the latest Linux kernel 6.14 Features, we are moving to the “derive_coerce_pointee” macro. This feature will make this version of the Linux kernel more stable.

Linux Kernel 6.14 Features

Linux kernel 6.14 promises support for KVM hypervisor service for user-mode VMM in LoongArch. Also important is that it introduces PCI error recovery mechanism for IBM System/390.

Other Linux kernel 6.14 Features include PM suspend/resume support for Raspberry Pi, manual fan control for Dell XPS 9370 laptops, and broader support for various hardware such as SoundWire devices and Rockchip SFC controllers.

Linux kernel 6.14 has been updated with updated drivers to improve hardware compatibility. To go into more detail, these include a new driver for the SM8750 platform, support for the MT8188 Mali-G57 MC3 in the Panfrost driver, an EDAC driver for Loongson SoCs, and support for various game controllers and audio chips.

Linux kernel 6.14 changes in the networking section

In the networking front, Linux kernel 6.14 supports IPsec for aggregated and fragmented internal IPs. It is worth noting that in the networking department, a big step has been taken towards large packet transmission, PHY statistics reporting, and network notifications for IPv4 and IPv6 address changes.

Another improvement in Linux kernel 6.14 is the improvement in ALSA APIs for MIDI 2.0. This kernel version also supports different SoCs and better management of NFS sessions, which reduces the time it takes to suspend and resume systems on certain machines.

Linux kernel 6.14 Release Date

The final version of Linux kernel 6.14 is expected to be released in late March 2025. Of course, the exact release date will depend on how many Release Candidate milestones are announced during this time. To break this down, if there are only seven RCs, we can expect it on March 23rd, but if there are eight, it will probably arrive on March 30th.

How to Download Linux Kernel 6.14?

You can download the first Release Candidate of Linux Kernel 6.14 from Linus Torvalds’ git tree, directly. If this is too complicated for you, you can easily download it from the kernel website.

Note that this is a pre-release version! So it is not recommended for use on production machines at all!

Please subscribe to us on Facebook, YouTube, Telegram, and X.

Also, you may like to read the following articles:

Enable Kernel Crash Dump on Debian

Upgrade Rocky Linux 9 Kernel To The Latest Version

Upgrade Debian Kernel Without Network Connection

Enable Kernel Crash Dump on Ubuntu

Upgrade Linux Kernel on AlmaLinux 9

How To Check Installed Linux Kernel in Command Line

Alternative Solutions: Managing Hardware Compatibility

The original article highlights several improvements in Linux kernel 6.14 aimed at improving hardware compatibility, including updated drivers for new platforms, SoCs, and peripherals. While updating the kernel is a primary way to gain access to these enhancements, here are two alternative approaches to improve hardware compatibility, particularly in situations where upgrading the kernel is not immediately feasible or desirable:

1. Backporting Drivers and Modules:

Instead of upgrading the entire kernel, specific drivers or modules that provide compatibility for newer hardware can be "backported" from a newer kernel version to an older one. This involves taking the source code for the desired driver from, say, the Linux kernel 6.14 source tree, and adapting it to compile and run on the older kernel.

Explanation:

Backporting is a complex process requiring a good understanding of kernel internals and the specific driver’s dependencies. The key idea is that many drivers are relatively self-contained, and their core logic might be compatible with older kernel interfaces with some modifications. However, API changes between kernel versions are common, so the backported driver might need to be adjusted to work with the older kernel’s data structures and functions. This can involve:

• Resolving dependency issues: Identifying any functions or data structures used by the driver that have changed or are unavailable in the older kernel.
• Adjusting the build system: Modifying the driver’s Makefile to compile correctly against the older kernel’s headers and libraries.
• Porting code: Adapting the driver’s source code to use the older kernel’s APIs while preserving its functionality.

Example (Illustrative – Requires significant adaptation for real-world scenarios):

Let’s imagine a simplified scenario where you want to backport a driver for a new type of network interface card (NIC). Assume that the primary difference between the older kernel and the new kernel’s driver is a slightly changed data structure used to represent network packets. In the newer kernel, the structure includes a new field packet_timestamp.

// Newer Kernel (Linux 6.14)
struct sk_buff_enhanced {
  unsigned char *data;
  unsigned int len;
  unsigned long packet_timestamp;  // New field
  // ... other fields
};

// Older Kernel (Example - Linux 5.4)
struct sk_buff {
  unsigned char *data;
  unsigned int len;
  // ... other fields
};

// Simplified Backported Driver Snippet
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>

static int my_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent) {
  struct net_device *netdev;
  // ... device initialization ...

  netdev = alloc_netdev(0, "mynic%d", NET_NAME_UNKNOWN, ether_setup);
  if (!netdev)
      return -ENOMEM;

  // Simulate receiving a packet (in a real driver, this would come from the hardware)
  #if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 14, 0)  //Conditional Compilation
      struct sk_buff_enhanced *skb = netdev_alloc_skb(netdev, 1500);
      skb->packet_timestamp = ktime_get_ns(); //Access the new field
  #else
      struct sk_buff *skb = netdev_alloc_skb(netdev, 1500);
  #endif

  // ... process the packet ...

  return 0;
}

static const struct pci_device_id my_nic_id_table[] = {
  { PCI_DEVICE(0xXXXX, 0xYYYY), },  // Replace with your device's vendor and device ID
  { 0, }
};
MODULE_DEVICE_TABLE(pci, my_nic_id_table);

static struct pci_driver my_nic_driver = {
  .name     = "my_nic_driver",
  .id_table = my_nic_id_table,
  .probe    = my_nic_probe,
  // ... other driver functions ...
};

module_init(init_module);
module_exit(cleanup_module);

MODULE_LICENSE("GPL");

In this example, the #if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 14, 0) preprocessor directive allows the code to conditionally access the packet_timestamp field only if the kernel version is 6.14 or later. On older kernels, this code path is skipped. In a real-world scenario, you might need to use different functions or data structures altogether to achieve the same functionality.

Important Considerations:

• Kernel Version Compatibility: Carefully check the compatibility of the driver with the target kernel version. Major API changes can make backporting difficult or impossible.
• Maintenance Overhead: Backported drivers might require ongoing maintenance to address security vulnerabilities or compatibility issues that arise in the future.
• Licensing: Ensure that the driver’s license allows for backporting and redistribution.
• Complexity: Backporting is an advanced task and should only be attempted by experienced kernel developers.

2. User-Space Drivers with Hardware Abstraction:

Another approach is to create a user-space driver that interacts with the hardware through a well-defined hardware abstraction layer (HAL). This approach isolates the driver from direct kernel dependencies, making it more portable across different kernel versions.

Explanation:

Traditionally, drivers run within the kernel to have direct access to hardware resources. However, it is possible to move some driver functionality to user space, communicating with the hardware through system calls or dedicated kernel modules that provide a simplified interface. The key is the HAL, which provides a consistent API for the user-space driver to access hardware features, regardless of the underlying kernel version or hardware specifics.

Benefits:

• Increased Portability: The user-space driver is less dependent on kernel APIs, making it easier to port to different kernel versions.
• Improved Stability: Crashes in the user-space driver are less likely to cause system-wide instability.
• Faster Development: User-space development is generally easier and faster than kernel-space development.

Example (Illustrative):

Let’s consider a simplified example where you need to control a custom hardware device. Instead of writing a kernel driver directly, you create a user-space application that communicates with a simple kernel module.

// Kernel Module (my_hal.c)
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>  // For copy_to_user and copy_from_user

#define DEVICE_NAME "my_device"

static int device_open(struct inode *inode, struct file *file);
static int device_release(struct inode *inode, struct file *file);
static ssize_t device_read(struct file *file, char __user *buf, size_t count, loff_t *offset);
static ssize_t device_write(struct file *file, const char __user *buf, size_t count, loff_t *offset);

static struct file_operations fops = {
    .open    = device_open,
    .release = device_release,
    .read    = device_read,
    .write   = device_write,
};

static int major_number;
static struct cdev my_device;

//Simulated Hardware access function (Replace with real hardware interaction)
static void hardware_set_value(int value){
    printk(KERN_INFO "Setting hardware value to %dn", value);
    //In real scenario, this function interact with hardware.
}

static int device_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "%s: Device openedn", DEVICE_NAME);
    return 0;
}

static int device_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "%s: Device closedn", DEVICE_NAME);
    return 0;
}

static ssize_t device_read(struct file *file, char __user *buf, size_t count, loff_t *offset) {
    // Simulate reading data from the hardware (replace with actual hardware read)
    char data[16] = "Hardware Data";
    size_t len = strlen(data);

    if (count > len)
        count = len;

    if (copy_to_user(buf, data, count))
        return -EFAULT;

    return count;
}

static ssize_t device_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) {
    int value;
    char kernel_buffer[16];

    if (count > sizeof(kernel_buffer) - 1)
        return -EINVAL;

    if (copy_from_user(kernel_buffer, buf, count))
        return -EFAULT;

    kernel_buffer[count] = '';  // Null-terminate the string

    if (kstrtoint(kernel_buffer, 10, &value) == 0) {
        hardware_set_value(value); // Call simulated hardware access function.
    } else {
        printk(KERN_INFO "Invalid input: %sn", kernel_buffer);
        return -EINVAL;
    }
    return count;
}

static int __init my_module_init(void) {
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Registering char device failed with %dn", major_number);
        return major_number;
    }
    printk(KERN_INFO "Registered device with major number %dn", major_number);

    cdev_init(&my_device, &fops);
    my_device.owner = THIS_MODULE;
    int err = cdev_add(&my_device, MKDEV(major_number, 0), 1);
    if (err) {
        printk(KERN_ALERT "Cdev add failed with %dn", err);
        unregister_chrdev(major_number, DEVICE_NAME);
        return err;
    }

    return 0;
}

static void __exit my_module_exit(void) {
    cdev_del(&my_device);
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Unregistered devicen");
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple character device driver for HAL example");

// User-Space Application (user_app.c)
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define DEVICE_PATH "/dev/my_device"

int main() {
    int fd;
    char buffer[1024];

    fd = open(DEVICE_PATH, O_RDWR);
    if (fd < 0) {
        perror("Failed to open device");
        return 1;
    }

    // Write data to the device (to set the hardware value)
    const char *write_data = "123";
    ssize_t bytes_written = write(fd, write_data, strlen(write_data));
    if (bytes_written < 0) {
        perror("Failed to write to device");
        close(fd);
        return 1;
    }
    printf("Wrote %zd bytes to the devicen", bytes_written);

    // Read data from the device
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes_read < 0) {
        perror("Failed to read from device");
        close(fd);
        return 1;
    }
    buffer[bytes_read] = '';
    printf("Read %zd bytes from the device: %sn", bytes_read, buffer);

    close(fd);
    return 0;
}

Explanation:

• Kernel Module (my_hal.c): Creates a character device /dev/my_device. The device_read and device_write functions provide a simple interface for user-space applications to read and write data to the device. The hardware_set_value function simulates the interaction with the hardware. In a real implementation, this function would contain the actual code to control the device. The critical point is that the kernel module provides a stable API, regardless of the underlying hardware or kernel version.
• User-Space Application (user_app.c): Opens the character device and uses read and write system calls to communicate with the kernel module. The application sends a value to the kernel module, which then "sets" the hardware value.

Compilation and Execution:

1. Compile the kernel module:

   make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
   sudo insmod my_hal.ko

2. Create the device node:

   sudo mknod /dev/my_device c <major_number> 0  #Replace <major_number> with the actual major number

   (Check kernel log after insmod to see major number)

3. Compile the user-space application:

   gcc user_app.c -o user_app

4. Run the user-space application:

   sudo ./user_app

Key Considerations:

• Performance Overhead: User-space drivers might incur a performance penalty compared to kernel drivers due to the overhead of context switching between user space and kernel space.
• Security: Proper security measures must be implemented to prevent unauthorized access to the hardware.
• HAL Design: The design of the HAL is crucial for portability and maintainability. It should be well-defined and provide a stable API for the user-space driver.
• Real-Time Requirements: User-space drivers might not be suitable for applications with strict real-time requirements.

In conclusion, while upgrading to Linux kernel 6.14 is the direct route to leveraging its new hardware support, backporting drivers and implementing user-space drivers with a HAL offer viable alternatives, especially when kernel upgrades are not feasible. However, both approaches require careful planning, development effort, and ongoing maintenance.