Post Syndicated from daroc original https://lwn.net/Articles/1013844/

The LLVM project’s Fortran compiler, which has for many years gone by the name “flang-new”, will now simply be “flang”, starting from LLVM’s 20.1.0 release on March 4. The

announcement, which includes details about the history of flang, comes after a long period of development and discussion. The community has considered renaming flang several times before now, but has always held off out of a feeling that the compiler was not yet ready. Now, the members of the project believe that flang has become stable and complete enough to earn its name.

We are almost 10 years from the first announcement of what would
become LLVM Flang. In the LLVM monorepo alone there have been close
to 10,000 commits from around 400 different contributors. Undoubtedly
more in Classic Flang before that.

Post Syndicated from daroc original https://lwn.net/Articles/1013581/

The Python project’s recent switch to a tail-calling interpreter may not provide as large a speed advantage as initially thought. A blog post from Nelson Elhage gives the details. In short, switching to a tail-call-based interpreter accidentally works around an unfixed regression in LLVM 19. On other compilers, the performance benefit (while still present) is more moderate.

When the tail-call interpreter was announced, I was surprised and impressed by the performance improvements, but also confused: I’m not an expert, but I’m passingly-familiar with modern CPU hardware, compilers, and interpreter design, and I couldn’t explain why this change would be so effective. I became curious – and perhaps slightly obsessed – and the reports in this post are the result of a few weeks of off-and-on compiling and benchmarking and disassembly of dozens of different Python binaries, in an attempt to understand what I was seeing.

Post Syndicated from daroc original https://lwn.net/Articles/1013561/

Security updates have been issued by Debian (openvpn and thunderbird), Fedora (buildah, chromium, podman-tui, python-spotipy, qt6-qtwebengine, and vim), Mageia (chromium-browser-stable and gpac), Oracle (krb5), Red Hat (firefox, kernel, kernel-rt, libxml2, and pcs), SUSE (buildah, chromedriver, chromium, firefox, go1.23, go1.24, grype, python, python311-GitPython, ruby3.4-rubygem-rack, thunderbird, and xen), and Ubuntu (xorg-server, xorg-server-hwe-16.04, xorg-server-hwe-18.04).

Post Syndicated from daroc original https://lwn.net/Articles/1013395/

Greg Kroah-Hartman has announced the release of four more stable kernels:
6.13.6,
6.12.18,
6.6.81, and
6.1.130.
Unlike a normal release, Kroah-Hartman did not call for all users to
update their kernels. Specifically, the 6.6.81 kernel is currently broken on
i386 systems, and users should wait for 6.6.82.

Post Syndicated from daroc original https://lwn.net/Articles/1012946/

On January 20, Thomas Weißschuh shared a new

patch set implementing an alternate method for checking the integrity of
loadable kernel modules. This mechanism, which checks module integrity based
on hashes computed at build time instead of using cryptographic signatures,
could enable reproducible kernel builds in more contexts. Several distributions
have already expressed interest in the patch set if Weißschuh can get it
into the kernel.

Post Syndicated from daroc original https://lwn.net/Articles/1013336/

Security updates have been issued by Debian (chromium), Fedora (firefox and man2html), Mageia (erlang, ffmpeg, and vim), Oracle (doxygen, firefox, python-jinja2, squid, and webkit2gtk3), Red Hat (nodejs:18), SUSE (emacs, go1.23, go1.24, and pcp), and Ubuntu (ansible, firefox, linux-azure, linux-nvidia, and python-django).

Post Syndicated from daroc original https://lwn.net/Articles/1011803/

Functional programming languages have a long association with graphs. In the
1990s, it was even thought that parallel graph-reduction
architectures could make functional programming languages much faster than their
imperative counterparts. Alas, that prediction mostly failed to materialize.
Even though graphs are still used as a theoretical formalism in order to define
and optimize functional languages (such as Haskell’s

spineless tagless graph-machine), they are still mostly compiled down to the same old
non-parallel assembly code that every other language uses. Now, two
projects —

Bend and

Vine — have sprung up attempting to change that, and prove that
parallel graph reduction can be a useful technique for real programs.

Post Syndicated from daroc original https://lwn.net/Articles/1012367/

Security updates have been issued by Debian (emacs, freerdp2, and gst-plugins-good1.0), Fedora (java-17-openjdk, python3.6, and xorg-x11-server-Xwayland), Mageia (radare2), SUSE (libX11, openvswitch3, postgresql13, procps, ruby2.5, webkit2gtk3, and xorg-x11-server), and Ubuntu (git, linux-aws, linux-aws, linux-aws-6.8, linux-aws, linux-oracle, linux-oracle-5.4, linux-ibm, linux-intel-iotg, linux-intel-iotg-5.15, and linux-oem-6.11).

Post Syndicated from daroc original https://lwn.net/Articles/1010905/

The

Faster CPython project has been working to speed up the Python interpreter
for the past several years. Now, Ken Jin, a member of the project, has merged a

new set of changes that
have been

benchmarked as improving performance by 10% for some architectures.
The only change is switching from using computed goto statements to using
tail calls as part of the implementation of Python’s bytecode interpreter — but that change allows
modern compilers to generate significantly better code.

Post Syndicated from daroc original https://lwn.net/Articles/1010404/

The Linux kernel supports attaching BPF programs to many operations.
This is generally safe because the BPF verifier ensures
that BPF programs can’t misuse kernel resources, run indefinitely, or otherwise
escape their boundaries. There is continuing tension, however, between trying
to expand the capabilities of BPF programs and ensuring that the verifier can
handle every edge case. On February 14, Juntong Deng

shared a proof-of-concept patch set that
adds some run-time checks to BPF to make it possible in the future to interrupt
a running BPF program.

Post Syndicated from daroc original https://lwn.net/Articles/1011263/

Greg Kroah-Hartman has released another four stable kernels:
6.13.4,
6.12.16,
6.6.79, and
6.1.129. As usual, all users are advised to upgrade.

Post Syndicated from daroc original https://lwn.net/Articles/1011262/

Security updates have been issued by AlmaLinux (bind, bind9.16, and mysql:8.0), Debian (chromium, djoser, libtasn1-6, and postgresql-13), Fedora (python3.12 and vim), Red Hat (libpq, postgresql, postgresql:13, postgresql:15, and postgresql:16), Slackware (ark), SUSE (brise, chromium, emacs, google-osconfig-agent, grafana, grub2, helm, kernel, openssh, openssl-1_1, ovmf, postgresql13, postgresql14, postgresql15, and postgresql17), and Ubuntu (gnutls28, libtasn1-6, openssl, python3.10, python3.12, python3.8, and webkit2gtk).

Post Syndicated from daroc original https://lwn.net/Articles/1009509/

Steven Rostedt recently posted

a patch set that could help improve the performance of certain user-space
applications by giving the scheduler more context about when they are safe to
interrupt. The patch set lets programs request a small grace window
before they can be interrupted so that they can relinquish any locks, decreasing the
amount of time that other threads have to spend waiting. Rostedt shared
performance numbers suggesting that the patch might cut the amount of time spent
acquiring locks in half for some programs — although, since his test was
specifically tuned for this case, real-world projects should expect a somewhat
less dramatic improvement. The change received some pushback from scheduler
maintainer Peter Zijlstra, who objected to the patch set’s approach.

Post Syndicated from daroc original https://lwn.net/Articles/1008714/

Kernel developers have been working to convert various internal interfaces to
use

folios; while this process has been progressing, there is still the
occasional regression introduced by the change. In December 2024, it was
discovered that installing a

Flatpak application could trigger a filesystem bug in
the kernel that would cause the software to read incorrect data from the disk.
The problem was quickly fixed — only for an another problem caused by the folio
rewrite to pop up in the same kernel subsystem. This was discovered by an Arch
Linux user, who noticed that selecting files in a Flatpak application was
causing kernel crashes. Now both bugs are fixed, but there may be more bugs to find.

Post Syndicated from daroc original https://lwn.net/Articles/1010352/

Greg Kroah-Hartman has released three more stable kernels:
6.13.3,
6.12.14, and
6.6.78.
There was a bit of confusion that resulted in the patch for
CVE 2025-21687
getting applied twice — but that doesn’t result in any problems for users of the
kernel, just a bit of extra noise in the CVE database, so Kroah-Hartman has
decided to leave the releases as-is instead of rushing another point release.

Post Syndicated from daroc original https://lwn.net/Articles/1010328/

Security updates have been issued by AlmaLinux (container-tools:rhel8, gcc, libxml2, nodejs:18, and nodejs:20), Debian (freerdp2, golang-glog, trafficserver, and tryton-client), Fedora (chromium, krb5, libheif, microcode_ctl, nginx, nginx-mod-fancyindex, nginx-mod-modsecurity, nginx-mod-naxsi, nginx-mod-vts, and webkitgtk), Mageia (ffmpeg, golang, postgresql13 and postgresql15, and python-zipp), Oracle (container-tools:ol8, gcc, gcc-toolset-13-gcc, gcc-toolset-14-gcc, kernel, libxml2, and nodejs:20), Red Hat (gcc, idm:DL1, and ipa), SUSE (buildah, chromium, glibc, kernel, kernel-firmware-all-20250206, libecpg6, postgresql15, python, python3, python311, and ruby3.4-rubygem-rack), and Ubuntu (intel-microcode).

Post Syndicated from daroc original https://lwn.net/Articles/1009765/

Security updates have been issued by AlmaLinux (doxygen, gcc-toolset-13-gcc, gcc-toolset-14-gcc, kernel, and libxml2), Debian (chromium, postgresql-13, and webkit2gtk), Fedora (krb5, openssl, and python3.13), Mageia (ark, ofono, and perl-Net-OAuth, perl-Crypt-URandom, perl-Module-Build), Oracle (firefox, gcc, gcc-toolset-14-gcc, kernel, openssl, tbb, and thunderbird), Red Hat (libxml2), SUSE (chromium, golang-github-prometheus-prometheus, grafana, kernel, kernel-firmware-ath10k-20250206, kernel-firmware-bnx2-20250206, kernel-firmware-brcm-20250206, kernel-firmware-chelsio-20250206, kernel-firmware-dpaa2-20250206, kernel-firmware-mwifiex-20250206, kernel-firmware-platform-20250206, kernel-firmware-realtek-20250206, kernel-firmware-serial-20250206, kernel-firmware-ueagle-20250206, libtasn1, python312, qemu, SUSE Manager Client Tools, SUSE Manager Client Tools MU 5.0.3, and ucode-intel-20250211), and Ubuntu (activemq and libsndfile).

Post Syndicated from daroc original https://lwn.net/Articles/1007921/

Miguel Ojeda gave

a keynote at

FOSDEM 2025 about the history of the

Rust-for-Linux
project, and the current attitude of people in the kernel community toward the
experiment. Unlike his

usual talks, this talk didn’t focus so much on the current
state of the project, but rather on discussing history
and predictions for the future. He ended up presenting quotes from more than 30
people involved in kernel development about what they thought of the project and
expected going forward.

Post Syndicated from daroc original https://lwn.net/Articles/1008502/

Security updates have been issued by Debian (openjdk-17), Fedora (firefox, FlightGear, java-1.8.0-openjdk, java-11-openjdk, java-latest-openjdk, and SimGear), Mageia (gstreamer), Red Hat (firefox, kernel, kernel-rt, libsoup, and python-jinja2), SUSE (bind, curl, dcmtk, etcd, firefox, google-osconfig-agent, krb5, openssl-1_1, podman, python311-cbor2, thunderbird, wget, and xrdp), and Ubuntu (glibc).

Post Syndicated from daroc original https://lwn.net/Articles/1007689/

Jake Hillion gave

a presentation at

FOSDEM about using

sched_ext, the BPF
scheduling framework that was introduced in kernel version 6.12, to help find
elusive concurrency problems. In collaboration with Johannes Bechberger, he has
built a scheduler that can reveal theoretically possible but unobserved
concurrency bugs in test code in a few minutes. Since their scheduler only
relies on mainline kernel features, it can theoretically be applied to any
application that runs on Linux — although there are a number of caveats since
the project is still in its early days.