kbuild: rust: keep Rust objects out of Clang LTO with inline helpersgrafted

Under `CONFIG_LTO_CLANG` + `CONFIG_RUST_INLINE_HELPERS`, one may hit
`objtool` errors such as:

    vmlinux.o: error: objtool: _R..._3Gsp4boot+0xd6a:
    can't find jump dest instruction at .text._R..._3Gsp4boot+0x1dfd

The reason is that in such builds, the Clang invocation that compiles
the combined Rust plus helpers bitcode emits LLVM bitcode (again) --
the final code generation happens in the linker's LTO step, which the
`-mllvm` trap options passed to Clang do not reach.

This, in turn, means that unreachable traps are missing, and the
impossible paths do not merely fallthrough to the next symbol, but past
the end of their own section, since LTO builds place each function in
its own section.

Thus filter `CC_FLAGS_LTO` out of the Clang invocation, so that it always
emits machine code directly, with the traps in place.

Assisted-by: LLM
Cc: Gary Guo <gary@garyguo.net>
Cc: Boqun Feng <boqun@kernel.org>
Cc: Alice Ryhl <aliceryhl@google.com>
Cc: Matthew Maurer <mmaurer@google.com>
Cc: Josh Poimboeuf <jpoimboe@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: stable@vger.kernel.org
Fixes: 3a2486cc1da5 ("kbuild: rust: provide an option to inline C helpers into Rust")
Acked-by: Gary Guo <gary@garyguo.net>
Link: https://patch.msgid.link/20260816133233.197500-2-ojeda@kernel.org
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

1 files changed, 124 insertions, 0 deletions

diff --git a/fs/squashfs/file_direct.c b/fs/squashfs/file_direct.c
new file mode 100644
index 000000000..2c3e809d6
--- /dev/null
+++ b/fs/squashfs/file_direct.c
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/pagemap.h>
+#include <linux/mutex.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+#include "page_actor.h"
+
+/* Read separately compressed datablock directly into page cache */
+int squashfs_readpage_block(struct folio *folio, u64 block, int bsize,
+		int expected)
+{
+	struct page *target_page = &folio->page;
+	struct inode *inode = folio->mapping->host;
+	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+	loff_t file_end = (i_size_read(inode) - 1) >> PAGE_SHIFT;
+	int mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
+	loff_t start_index = folio->index & ~mask;
+	loff_t end_index = start_index | mask;
+	loff_t index;
+	int i, pages, bytes, res = -ENOMEM;
+	struct page **page, *last_page;
+	struct squashfs_page_actor *actor;
+	void *pageaddr;
+
+	if (end_index > file_end)
+		end_index = file_end;
+
+	pages = end_index - start_index + 1;
+
+	page = kmalloc_array(pages, sizeof(void *), GFP_KERNEL);
+	if (page == NULL)
+		return res;
+
+	/* Try to grab all the pages covered by the Squashfs block */
+	for (i = 0, index = start_index; index <= end_index; index++) {
+		page[i] = (index == folio->index) ? target_page :
+			grab_cache_page_nowait(folio->mapping, index);
+
+		if (page[i] == NULL)
+			continue;
+
+		if (PageUptodate(page[i])) {
+			unlock_page(page[i]);
+			put_page(page[i]);
+			continue;
+		}
+
+		i++;
+	}
+
+	pages = i;
+
+	/*
+	 * Create a "page actor" which will kmap and kunmap the
+	 * page cache pages appropriately within the decompressor
+	 */
+	actor = squashfs_page_actor_init_special(msblk, page, pages, expected,
+						start_index << PAGE_SHIFT);
+	if (actor == NULL)
+		goto out;
+
+	/* Decompress directly into the page cache buffers */
+	res = squashfs_read_data(inode->i_sb, block, bsize, NULL, actor);
+
+	last_page = squashfs_page_actor_free(actor);
+
+	if (res < 0)
+		goto mark_errored;
+
+	if (res != expected || IS_ERR(last_page)) {
+		res = -EIO;
+		goto mark_errored;
+	}
+
+	/* Last page (if present) may have trailing bytes not filled */
+	bytes = res % PAGE_SIZE;
+	if (end_index == file_end && last_page && bytes) {
+		pageaddr = kmap_local_page(last_page);
+		memset(pageaddr + bytes, 0, PAGE_SIZE - bytes);
+		kunmap_local(pageaddr);
+	}
+
+	/* Mark pages as uptodate, unlock and release */
+	for (i = 0; i < pages; i++) {
+		flush_dcache_page(page[i]);
+		SetPageUptodate(page[i]);
+		unlock_page(page[i]);
+		if (page[i] != target_page)
+			put_page(page[i]);
+	}
+
+	kfree(page);
+
+	return 0;
+
+mark_errored:
+	/* Decompression failed.  Target_page is
+	 * dealt with by the caller
+	 */
+	for (i = 0; i < pages; i++) {
+		if (page[i] == NULL || page[i] == target_page)
+			continue;
+		flush_dcache_page(page[i]);
+		unlock_page(page[i]);
+		put_page(page[i]);
+	}
+
+out:
+	kfree(page);
+	return res;
+}