Building header files into the kernel

Joel, why even bother remounting? You can just directly use the pre-existing internal kernel mount as if it was a special form of swappable kernel memory. CONFIG_BIG_KEYS actually does that, and the the bpfilter user mode helper module copies data that is baked into its module (as discardable init data) into the main internal tmpfs mount, so there is precedent for most of this.

I'll be showing code as if making the file swappable was unconditional, but it should be very obvious how to add a config option that hybridizes what patch V5 has, and the below.

One word of warning: This basically requires CONFIG_TMPFS. It will also work if !CONFIG_SHMEM, because then it uses tiny-shmem (which is ramfs). However using CONFIG_SHMEM without CONFIG_TMPFS yields a tmpfs that is excessively limited.

Now lets create the file in tmpfs, and copy the data into it:

static struct path *mem_path;

static int __init ikheaders_init(void)
{
	struct proc_dir_entry *entry;
        size_t kernel_headers_data_size = &kernel_headers_data_end - &kernel_headers_data;
        int err;

        ssize_t written;
	loff_t pos = 0;

        /* copy data to a new tmpfs file, so it can be swapped out */
        mem_file = shmem_kernel_file_setup("", kernel_headers_data_size, 0);
        if (IS_ERR(mem_file)) {
		err = PTR_ERR(mem_file);
		goto err_no_fput;
	}

        written = kernel_write(mem_file, kernel_headers_data, kernel_headers_data_size, &pos);
        if (written != kernel_headers_data_size) {
		err = written;
		if (err >= 0)
			err = -ENOMEM;
		goto error;
	}

	/* create the current headers file */
	entry = proc_create("kheaders.tar.xz", S_IRUGO, NULL,
			    &ikheaders_file_ops);
	if (!entry) {
		err = -ENOMEM;
		goto error;
	}
	
	proc_set_size(entry,
		      kernel_headers_data_size);
	return 0;
error:
	fput(mem_file);
error_no_fput:
	return ret;
}

static void __exit ikheaders_cleanup(void)
{
	remove_proc_entry("kheaders.tar.xz", NULL);
	path_put(mem_path);
}

OK. Next up, we need to change the section the baked-in data is stored in to be .init.data so it gets discarded after init.

asm (
"	.pushsection .init.data, \"a\"	\n"
/*...*/
);

Almost done. All that is left is to make reads of the proc file return data from the in memory file. There are actually several ways to approach this. We could use a magic symlink to the internal file, similar to how the proc file descriptor symlinks work. But to make this act as much like a normal file as possible, the following might be easiest. It is definitely a bit odd to have the read delegate back to vfs_read, but as far as I can tell it should work. I'd bet one of VFS guys can come up with some improvements to this approach.

static int ikheaders_open_current(struct inode *inode, struct file *file)
{
	struct file *mem_file
	file = dentry_open(path, O_RDONLY, current_cred());

	if (IS_ERR(file)) 
		return PTR_ERR(file);

	file->private_data = mem_file;
	return 0;
}
static ssize_t
ikheaders_read_current(struct file *file, char __user *buf,
		      size_t len, loff_t *offset)
{
        struct file *mem_file = file->private_data;
	return vfs_read(mem_file, buf, len, offset);
}
static int ikheaders_release_current(struct inode *inode, struct file *file)
{
        struct file *mem_file = file->private_data;
	fput(mem_file);
	return 0;
}

static const struct file_operations ikheaders_file_ops = {
        .open = ikheaders_open_current,
        .release = ikheaders_release_current,
	.read = ikheaders_read_current,
	.llseek = default_llseek,
};

Please note that all this code is untested, and is intended to a show the basic approach, although it probably works as-is, modulo any typos (since most of it was copy-pasted from existing parts of the kernel or your patch).

Hope you find this helpful, or at least interesting