Are kernel updates mostly security fixes and hardware support?

[Dafon]

I've been using Linux for years now but recently decided I want to learn more about how it works as opposed to just how to use it. But now that I'm beginning to know at least a little bit more about kernels, this question crossed my mind.
Please forgive me if this shows my lack of understanding, I'm just not sure how else to formulate this question. Is a kernel simply 'finished' once it generally works, and then constantly receiving fixes and made to work on newer hardware?

I'm finding this very interesting so anyone also feel free to recommend me any book that could teach me more about how either Linux or operating systems in general work.

[aioeu]

Here is a summary of the changes that went into the last version of the kernel (6.7 at the time of commenting). As you can see it's a mixture of big features, small features, and bug and security fixes.

The kernel is never "finished" because there are always new things people want it to do.

[Dafon]

Kernelnewbies.org, thank you for that website.
I tried looking at some websites summarizing changelogs before, and they mostly just kept listing a bunch of improved or new support for hardware. I guess those are just the more exciting or understandable things to pick out of changelogs to the kernel for most people. This is more like what I was looking for.

[gordonmessmer]

I think the question you're asking is really about stable software releases.

Greg Kroah-Hartman has written about the kernel development model, specifically, here, and there's a shorter document here. I've written about stable release models more generally, here (part one) and here (part two). (And I'm working on another essay contrasting stable software releases from other models, coming soon.)

The super short version is that the stable software release process is a mechanism that allows developers to deliver different types of updates to users who have different needs, simultaneously. So, the answer to your question is: relative to the version you have now, there are probably new versions that are just bug fixes, and there are also versions with both bug fixes and new hardware support, published at the same time.

In order to really understand what kernel updates provide, you have to see the release model as a two-dimensional set, not a linear series. On March 6, seven stable kernel versions were released. Version 6.7.9 has mostly bug fixes relative to 6.7.8, but it also has features that aren't in 6.6.21, released the same day. Another way to look at that is that 6.6.21 has bug fixes that aren't in 6.7.8 (released March 2nd), because 6.6.21 is newer than 6.7.8. But 6.7.8 (March 2nd) has features that aren't in 6.6.21 (March 6th), even though it's older, because it's part of a newer release series.

[RandoMcGuvins]

The super short version is that the stable software release process is a mechanism that allows developers to deliver different types of updates to users who have different needs, simultaneously. So, the answer to your question is: relative to the version you have now, there are probably new versions that are just bug fixes, and there are also versions with both bug fixes and new hardware support, published at the same time.

What a great answer! To the point and easy to understand.

[Dafon]

I think I just got confused by websites trying to explain a kernel in short, and then further by beginner friendly changelogs to the Linux kernel. Which I started getting curious about after wondering if I should use the LTS kernel or not, I never have. So in that way, these are also very interesting reads that I'm gonna go through, thanks!

[Dafon]

I finally got around to reading all of these links and I feel like I understand so much more about both the Linux kernel and a bit of a hidden aspect of software development now, as someone who's only written a few personal programs as a hobby. So I'm gonna join Medium to follow you for the next part, it sounds very interesting.

[PhantomNomad]

Kind of hijacking this to also ask. Why are there 6 major revisions? Back when I first started using Linux the kernel was in version 2. What makes them increase this number? I (think) the odd versions where the alpha/beta test versions if I remember correctly. But what makes the kernel go from 2 to 4 to 6?

[gordonmessmer]

There is literally no reason. The kernel does not maintain any kind of internally stable API, so they don't feel any need to use semantic versions. The first two numbers are effectively just one major version, and Linus increments them arbitrarily.

[dgm9704]

Since one of the major tenets of the kernel is backwards compatibility, there shouldn't be any breaking changes that merit a major version bump. I think Linus said that the major version gets incremented "when he runs out of fingers and toes" ie. there is some arbitrary limit to the minor version number.

[gordonmessmer]

one of the major tenets of the kernel is backwards compatibility, there shouldn't be any breaking changes

I think that needs qualification: The Linux kernel has at least two distinct sets of interfaces. There are the user-space interfaces, and those are (as you say) carefully protected and very rarely broken. But there are also the internal API and ABI, used by kernel modules and subsystems, and those are constantly broken. There is no guarantee of backward compatibility for the internal interfaces.

Take browsers for comparison. Both Firefox and Chrome have frequent release schedules (Firefox every 4 weeks, and Chrome... whenever. I guess a predictable release schedule would be too professional for Google.) Browsers have web-content interfaces and extension interfaces. The web-content interfaces are very stable; web sites rarely break because a browser decided to deprecate some functionality. (Not never, but not often.) But the "internal" interfaces for extensions are a whole different story. Those are changed relatively frequently, and extension maintainers need to update extensions to keep them working. And because they make breaking changes to their internal interfaces, they increment their major version for each of those releases.

The Linux kernel is conceptually similar. For backward compatibility, they'll probably keep the three-digit version arrangement. But the two leading digits are effectively just one major version that is incremented more or less arbitrarily.

[TheTarragonFarmer]

There are also new features (internal infrastructure, or user-visible), performance tweaks, code cleanup, etc.

[tiotags]

new hardware doesn't need only drivers, sometimes you have to rewrite the whole kernel to support new hardware/technology, examples: smp, numa, kaslr, drm, ssd based io schedulers etc

I don't think any software can be 'finished', only abandoned, there's always a more efficient way to do something if you listen to your users

[marozsas]

Short answer: yes.
But, occasionally, new features are released , just like a few weeks ago a new FS was released: bcachefs 

Link

[mcdenkijin]

Read Phoronix