Linux – What are linux long term support kernels

arch linuxkernelltssupport-cycle

I'm running an arch linux server and recently switched to an lts kernel from the repositories.

Since I'm not rebooting the server very often, I want a stable kernel that is supported for a very long time. However, I noticed this specific arch linux lts kernel keeps getting updates. Some weeks ago I had installed the kernel 4.4.11 and now already a 4.4.12 update comes in.

Being surprised about the 'high' update rate on the lts kernel track, I checked kernel.org and it states the latest longterm kernel is already 4.4.13, so I guess I have to update soon again on my server.

The linux.com blog states, that the 4.4 kernel will be maintained for at least 2 years. But since there are already 13 updates (as in 4.4.13) in the last 5 months I don't really see the benefit of the long term support kernel.

With such a high update frequency I could also run my server on the latest stable kernel and I would be not much more busy with updates than on the lts track.

So, please explain me, what is the LTS kernel exactly designed for?

Best Answer

LTS does not mean that there will be no upgrades coming. LTS means that the packages will get minor upgrades to fix bugs and security problems when the 'standard' support for the version has stopped. It gives you the option/possibility to use your server in a safe way without you going to the next version that they support. The next version most often requires a complete installation.

If you do not want to have these kind of upgrades then you should not do (automatic) upgrades. You can then decide yourself which upgrades that you do manually. I would not consider this good practice since this weakens your server.

Related Solutions

Linux – What are the main differences between Unix and Linux kernels today

There is no unique thing named "the Unix kernel". There are multiple descendants of the original Unix kernel source code trunk that forked branches from it at different stages and that have evolved separately according to their own needs.

The mainstream ones these days are found in Operating Systems created either from System V source code: AIX, HPUX, Solaris or from BSD source code, OpenBSD, FreeBSD and Mac OS/X.

All of these kernels have their particular strengths and weaknesses, just like Linux and other "from scratch" Unix like kernels (minix, Gnu hurd, ...).

Here is a non exhaustive list of the areas where differences can be observed, in no particular order:

CPU architecture support
Availability of drivers
File systems supported
Virtualization capabilities
Scheduling features, (alternate scheduling classes, real-time, ...)
Modularity
Observability
Tunability
Reliability
Performance
Scalability
API stability between versions
Open/Close source, license used
Security (eg: privilege granularity)
Memory management

Linux – How to see which pacman updates are major

I don't have pacman, but I tested this against your provided input sample, saved to a file and passed to standard in like this:

cat versioninfo.dat | python highlight_major_versions.py

You should be able to pipe the output of your pacman command to the code in the same way. The output on my machine looks like this:

enter image description here

Blue indicates a major version update (i.e. 1st segment). Yellow indicates a minor version update (2nd segment). Red indicates missing version info, in this case because the library is new in this update. I don't do anything clever with - versioning - the - counts as part of the relevant dot-delimited segment.

#!/usr/bin/env python    
import fileinput

# ANSI escape codes for some colours
BLUE   = '\033[94m'
YELLOW = '\033[93m'
RED    = '\033[91m'
ENDC   = '\033[0m'

def colourise_by_version_change(line, prev_v, new_v):
    ''' Colourise the input line based on major/minor version change.'''
    prev_segments = prev_v.split('.')
    new_segments  = new_v.split('.')

    coloured_line = line
    if new_segments[0] > prev_segments[0]:
        coloured_line = BLUE + line + ENDC   
    elif new_segments[1] > prev_segments[1]:
        coloured_line = YELLOW + line + ENDC

    return coloured_line

if __name__ == '__main__':   
    for line in fileinput.input():
        line     = line.strip()
        elements = line.split()
        if len(elements) == 5:
            name, prev_v, new_v, size, size_unit = elements[:5]
            line = colourise_by_version_change(line, prev_v, new_v)

        # There's something missing, so point it out (e.g. a new version)
        else:
            line = RED + line + ENDC

        print line

Related Question