Skip to content
← ENGINEERING NOTES
KERNEL8 min read

Linux 7.4-rc1: Test a Record-Size Kernel Safely

Linux 7.4-rc1 closed the biggest merge window ever. Here is how to measure it yourself, boot an rc kernel safely, and bisect a regression to one commit.

BY ASHLIN DARIUS GOVINDASAMY

Linux 7.4-rc1 landed on 1 November 2026 after what coverage describes as the largest merge window in kernel history, roughly 20,000 commits in two weeks. When a kernel that size is the likely next long-term release, you do not wait for December and hope: you boot the release candidate on a spare machine and look for regressions yourself. This post shows how to measure the merge window with git, build and boot an rc kernel without risking your main install, and bisect a regression down to a single commit.

What happened in the 7.4 merge window

Every kernel cycle starts with a two-week merge window where maintainers send Linus Torvalds their pull requests, followed by weekly release candidates (rc1, rc2 and so on) that should contain mostly fixes. Press coverage of the 7.4-rc1 announcement reports about 19,671 commits for the window, against 16,267 for 7.3 by Phoronix's count. Torvalds reportedly gave a few reasons: developers expect 7.4 to be the year's LTS kernel, a large chunk of the diff is generated AMD GPU register offsets and bit masks, and a surge of AI-triggered work arrived early.

On that last point, coverage quotes him saying he is "much happier with the flood of AI triggered work going into the merge window" and calling it "a much healthier model", because the alternative is a flood of fixes during the stabilisation period. The practical read for operators: a bigger merge window means more new code that has had less time in the wild, which is exactly why rc testing by non-kernel-developers matters this cycle.

Measure the window yourself

You do not have to trust anyone's headline number. The mainline tree is public and git can count it in seconds. Clone once, then compare tags.

bash
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
cd linux

# Commits merged for 7.4 up to rc1 (non-merge commits only)
git rev-list --no-merges --count v7.3..v7.4-rc1

# Same for the previous cycle, for comparison
git rev-list --no-merges --count v7.2..v7.3-rc1

# Top ten authors in this window
git shortlog -sn --no-merges v7.3..v7.4-rc1 | head -10

# Which top-level areas changed the most
git diff --dirstat=files,0 v7.3..v7.4-rc1 | sort -rn | head -15
Count commits and contributors between releases

Your numbers may differ slightly from the press figures because counting methods differ: with or without merge commits, and from the previous final tag or the previous rc1. Say which one you used when you quote it.

QUICK CHECK

Why do kernel developers usually want big changes merged during the merge window rather than in later release candidates?

Boot an rc kernel without gambling your machine

The safe pattern is to build a kernel that is installed alongside your working one, so the bootloader can always fall back. Use your running configuration as a base, then let localmodconfig trim it to the modules actually loaded, which cuts build time dramatically. Do this on a test box or VM first.

bash
sudo apt install build-essential flex bison libssl-dev libelf-dev bc dwarves   # Debian/Ubuntu names

git checkout v7.4-rc2
cp /boot/config-$(uname -r) .config
make olddefconfig
yes "" | make localmodconfig        # only modules currently loaded
scripts/config --disable DEBUG_INFO_BTF   # optional: faster build if you do not need BTF

make -j"$(nproc)" LOCALVERSION=-rc-test
sudo make modules_install
sudo make install                    # writes vmlinuz, initramfs and updates the bootloader
Build v7.4-rc2 (or whichever rc is current) next to your stable kernel

Keep your known-good kernel as the default and boot the new one once. On GRUB systems, grub-reboot does exactly that: the next boot only uses the entry you name, and a hang or reset lands you back on the default.

bash
# list entries
grep -E "menuentry '" /boot/grub/grub.cfg | cut -d"'" -f2 | cat -n

# boot the rc entry exactly once
sudo grub-reboot "Advanced options for Ubuntu>Ubuntu, with Linux 7.4.0-rc2-rc-test"
sudo reboot

# after boot: confirm, then read warnings
uname -r
sudo dmesg --level=err,warn | head -50
One-shot boot of the test kernel

Found a regression? Bisect it

If rc2 breaks something that 7.3 handled fine, git bisect finds the guilty commit in about log2(N) steps. Even across a 20,000-commit window that is around fifteen builds. Mark 7.3 as good, the rc as bad, and let git pick the midpoints.

bash
git bisect start
git bisect bad v7.4-rc2
git bisect good v7.3

# git checks out a midpoint. Build, boot, test, then report:
make -j"$(nproc)" LOCALVERSION=-bisect && sudo make modules_install install
sudo grub-reboot "Advanced options for Ubuntu>Ubuntu, with Linux 7.3.0-bisect"
sudo reboot
# ...test...  then:
git bisect good      # or: git bisect bad

# When git names the first bad commit:
git bisect log > bisect.log
git bisect reset
Bisect between the last good release and the bad rc

You can automate it. Write a script that exits 0 for good, 1 to 127 (except 125) for bad, and 125 to skip an untestable commit, then run git bisect run ./test.sh. A VM with a reproducible test is ideal for this. When you have the commit, report it to the maintainers listed by scripts/get_maintainer.pl for that file and include your bisect log, config and dmesg. A bisected report gets fixed far faster than a vague one.

bash
git show --stat <first-bad-commit> | head -20
scripts/get_maintainer.pl -f drivers/net/ethernet/intel/e1000e/netdev.c
Find who to tell

QUICK CHECK

In git bisect run, what exit code tells git to skip a commit that cannot be tested?

›Why localmodconfig is worth the caveat

make localmodconfig reads the modules currently loaded (lsmod) and disables the rest, which can shrink a distro config build from hours to minutes. The caveat is that hardware not plugged in at that moment, such as a USB device or an optional GPU, is dropped from the config. If you are testing hardware support, plug everything in first or keep the full distro config.

Gotchas

  • Out-of-tree modules such as proprietary GPU drivers or ZFS may not build against a brand new rc kernel. Test on a machine that does not need them, or expect to wait for compatibility patches.
  • Secure Boot will reject unsigned self-built kernels. Use a test VM, enroll your own key, or disable it on a lab machine only.
  • Keep /boot space in mind. Each kernel plus initramfs is a few hundred megabytes and old rc builds pile up quickly.
  • Record the exact tag or commit you tested. rc2 and rc3 differ, and bug reports without a version are ignored.

Takeaway

  • 7.4-rc1 was reported on 1 November 2026 with roughly 20,000 commits, a record, and 7.4 is widely expected to be the next LTS.
  • Final release is expected late December, so you have weeks of rc cycle to test on.
  • Build with LOCALVERSION so the rc installs beside your good kernel, and use grub-reboot for one-shot boots.
  • If something regresses, bisect it and send the log to the maintainers. That is the highest-value thing a non-developer can do for a release.

SOURCES

  1. Linux 7.4-rc1 Released With Nice Performance Improvements, AMD Ryzen Zen 6 Preparations & AMDGPU HDMI 2.1 Default — Phoronix
  2. Linux 7.4-rc2 Released With FAT32 Optimization, AMDGPU HDMI 2.2 Improvement — Phoronix
  3. Linux 7.4-rc1 rolling out with a massive merge window driven heavily by AI — Neowin
  4. Linux Kernel 7.4 RC1 is Officially Released: Here's What's New — OSTechNix
  5. git-bisect documentation — Git

Frequently asked questions

When was Linux 7.4-rc1 released?

Linux 7.4-rc1 was released on 1 November 2026, closing a merge window reported at roughly 20,000 commits, the largest on record. rc2 followed about a week later.

When will Linux 7.4 be released?

Coverage points to late December 2026, around 20 December, if there are the usual seven or eight release candidates. A slip into January is possible if extra rcs are needed.

Is Linux 7.4 an LTS kernel?

Developers expect it to become the year's long-term support kernel, but reports say there is no official designation yet. Check kernel.org after the final release.

How do I find which commit broke my kernel?

Use git bisect with the last good release tag and the bad rc. It converges in roughly log2 of the commit count steps, around fifteen builds for a 20,000-commit range.

NEWSLETTER

Get the engineering notes in your inbox.

Kernels, GPUs, networks, AI infrastructure — and the things we broke along the way. No spam, one click to leave.

We store only your email address, to send you new articles. See our privacy policy.

TAGS

linuxkernellinux-7.4git-bisecttestingreleasesysadmin

RELATED

ENGINEERING NOTES

Things we built.Things we broke.Things we learned.