mirror of
https://github.com/torvalds/linux.git
synced 2025-12-07 20:06:24 +00:00
a7f7dbae94
The file-based iomem emulation was introduced to support writing paravirtualized drivers based on emulated iomem regions. However, the only driver that makes use of it is an example driver called mmapper, which was written over two decades ago. We now have several modern device emulation mechanisms, such as vhost-user-based virtio-uml. Remove the file-based iomem emulation support to reduce the maintenance burden. Signed-off-by: Tiwei Bie <tiwei.btw@antgroup.com> Link: https://patch.msgid.link/20251027054519.1996090-5-tiwei.bie@linux.dev Signed-off-by: Johannes Berg <johannes.berg@intel.com>
130 lines
3.6 KiB
C
130 lines
3.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/memblock.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/pfn.h>
|
|
#include <asm/page.h>
|
|
#include <asm/sections.h>
|
|
#include <as-layout.h>
|
|
#include <init.h>
|
|
#include <kern.h>
|
|
#include <kern_util.h>
|
|
#include <mem_user.h>
|
|
#include <os.h>
|
|
|
|
static int physmem_fd = -1;
|
|
|
|
/* Changed during early boot */
|
|
unsigned long high_physmem;
|
|
EXPORT_SYMBOL(high_physmem);
|
|
|
|
void map_memory(unsigned long virt, unsigned long phys, unsigned long len,
|
|
int r, int w, int x)
|
|
{
|
|
__u64 offset;
|
|
int fd, err;
|
|
|
|
fd = phys_mapping(phys, &offset);
|
|
err = os_map_memory((void *) virt, fd, offset, len, r, w, x);
|
|
if (err) {
|
|
if (err == -ENOMEM)
|
|
printk(KERN_ERR "try increasing the host's "
|
|
"/proc/sys/vm/max_map_count to <physical "
|
|
"memory size>/4096\n");
|
|
panic("map_memory(0x%lx, %d, 0x%llx, %ld, %d, %d, %d) failed, "
|
|
"err = %d\n", virt, fd, offset, len, r, w, x, err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* setup_physmem() - Setup physical memory for UML
|
|
* @start: Start address of the physical kernel memory,
|
|
* i.e start address of the executable image.
|
|
* @reserve_end: end address of the physical kernel memory.
|
|
* @len: Length of total physical memory that should be mapped/made
|
|
* available, in bytes.
|
|
*
|
|
* Creates an unlinked temporary file of size (len) and memory maps
|
|
* it on the last executable image address (uml_reserved).
|
|
*
|
|
* The offset is needed as the length of the total physical memory
|
|
* (len) includes the size of the memory used be the executable image,
|
|
* but the mapped-to address is the last address of the executable image
|
|
* (uml_reserved == end address of executable image).
|
|
*
|
|
* The memory mapped memory of the temporary file is used as backing memory
|
|
* of all user space processes/kernel tasks.
|
|
*/
|
|
void __init setup_physmem(unsigned long start, unsigned long reserve_end,
|
|
unsigned long len)
|
|
{
|
|
unsigned long reserve = reserve_end - start;
|
|
unsigned long map_size = len - reserve;
|
|
int err;
|
|
|
|
if (len <= reserve) {
|
|
os_warn("Too few physical memory! Needed=%lu, given=%lu\n",
|
|
reserve, len);
|
|
exit(1);
|
|
}
|
|
|
|
physmem_fd = create_mem_file(len);
|
|
|
|
err = os_map_memory((void *) reserve_end, physmem_fd, reserve,
|
|
map_size, 1, 1, 1);
|
|
if (err < 0) {
|
|
os_warn("setup_physmem - mapping %lu bytes of memory at 0x%p "
|
|
"failed - errno = %d\n", map_size,
|
|
(void *) reserve_end, err);
|
|
exit(1);
|
|
}
|
|
|
|
/*
|
|
* Special kludge - This page will be mapped in to userspace processes
|
|
* from physmem_fd, so it needs to be written out there.
|
|
*/
|
|
os_seek_file(physmem_fd, __pa(__syscall_stub_start));
|
|
os_write_file(physmem_fd, __syscall_stub_start, PAGE_SIZE);
|
|
|
|
memblock_add(__pa(start), len);
|
|
memblock_reserve(__pa(start), reserve);
|
|
|
|
min_low_pfn = PFN_UP(__pa(reserve_end));
|
|
max_low_pfn = min_low_pfn + (map_size >> PAGE_SHIFT);
|
|
}
|
|
|
|
int phys_mapping(unsigned long phys, unsigned long long *offset_out)
|
|
{
|
|
int fd = -1;
|
|
|
|
if (phys < physmem_size) {
|
|
fd = physmem_fd;
|
|
*offset_out = phys;
|
|
}
|
|
|
|
return fd;
|
|
}
|
|
EXPORT_SYMBOL(phys_mapping);
|
|
|
|
static int __init uml_mem_setup(char *line, int *add)
|
|
{
|
|
char *retptr;
|
|
|
|
*add = 0;
|
|
physmem_size = memparse(line,&retptr);
|
|
return 0;
|
|
}
|
|
__uml_setup("mem=", uml_mem_setup,
|
|
"mem=<Amount of desired ram>\n"
|
|
" This controls how much \"physical\" memory the kernel allocates\n"
|
|
" for the system. The size is specified as a number followed by\n"
|
|
" one of 'k', 'K', 'm', 'M', which have the obvious meanings.\n"
|
|
" This is not related to the amount of memory in the host. It can\n"
|
|
" be more, and the excess, if it's ever used, will just be swapped out.\n"
|
|
" Example: mem=64M\n\n"
|
|
);
|