570 lines
13 KiB
C
570 lines
13 KiB
C
|
/*
|
||
|
* plex86: run multiple x86 operating systems concurrently
|
||
|
*
|
||
|
* Copyright (C) 2000 Frank van der Linden (fvdl@wasabisystems.com)
|
||
|
* Copyright (C) 2000 Alexander Langer <alex@big.endian.de>
|
||
|
*
|
||
|
* License as published by the Free Software Foundation; either version 2 of
|
||
|
* the License, or (at your option) any later version.
|
||
|
*
|
||
|
* This library is distributed in the hope that it will be useful, but WITHOUT
|
||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||
|
* License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU Lesser General Public License
|
||
|
* along with this library; if not, write to the Free Software Foundation,
|
||
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
*/
|
||
|
|
||
|
#define DIAGNOSTIC 1
|
||
|
#define CDEV_MAJOR 20
|
||
|
#define timer_t __bsd_timer_t
|
||
|
#define write_eflags __freebsd_write_eflags
|
||
|
#define read_eflags __freebsd_read_eflags
|
||
|
|
||
|
/* XXX recheck, which includes are needed */
|
||
|
#include <sys/param.h>
|
||
|
#include <sys/types.h>
|
||
|
#include <sys/systm.h>
|
||
|
|
||
|
#include <sys/proc.h>
|
||
|
#include <sys/conf.h>
|
||
|
#include <sys/exec.h>
|
||
|
#include <sys/malloc.h>
|
||
|
#include <sys/syslog.h>
|
||
|
#include <sys/queue.h>
|
||
|
#include <sys/signalvar.h>
|
||
|
#include <sys/mman.h>
|
||
|
#include <sys/kernel.h>
|
||
|
#include <sys/linker.h>
|
||
|
#include <sys/sysproto.h>
|
||
|
|
||
|
#include <sys/module.h>
|
||
|
|
||
|
#include <vm/vm.h>
|
||
|
|
||
|
#include <machine/cpu.h>
|
||
|
|
||
|
#undef timer_t
|
||
|
#undef write_eflags
|
||
|
#undef read_eflags
|
||
|
|
||
|
#include "plex86.h"
|
||
|
#define IN_HOST_SPACE
|
||
|
#include "monitor.h"
|
||
|
|
||
|
static MALLOC_DEFINE(M_PLEX86, "plex86", "Plex86 mem");
|
||
|
|
||
|
static d_open_t plex86_open;
|
||
|
static d_close_t plex86_close;
|
||
|
static d_mmap_t plex86_mmap;
|
||
|
static d_ioctl_t plex86_ioctl;
|
||
|
|
||
|
static unsigned retrieve_phy_pages(Bit32u *, int, void *, unsigned, int);
|
||
|
static vm_t *find_vm(struct proc * p);
|
||
|
static void register_vm(vm_t * vm, struct proc * p);
|
||
|
static void unregister_all(struct proc * p);
|
||
|
|
||
|
static struct cdevsw plex86_cdevsw = {
|
||
|
/* open */ plex86_open,
|
||
|
/* close */ plex86_close,
|
||
|
/* read */ noread,
|
||
|
/* write */ nowrite,
|
||
|
/* ioctl */ plex86_ioctl,
|
||
|
/* poll */ nopoll,
|
||
|
/* mmap */ plex86_mmap,
|
||
|
/* strat */ nostrategy,
|
||
|
/* name */ "plex86",
|
||
|
/* major */ CDEV_MAJOR,
|
||
|
/* dump */ nodump,
|
||
|
/* psize */ nopsize,
|
||
|
/* flags */ 0,
|
||
|
/* bmaj */ -1
|
||
|
};
|
||
|
|
||
|
/* For use with make_dev/destroy_dev */
|
||
|
static dev_t plex86_dev;
|
||
|
|
||
|
static struct plex86_softc {
|
||
|
int sc_open;
|
||
|
} plex86sc;
|
||
|
|
||
|
monitor_pages_t monitor_pages;
|
||
|
|
||
|
/*
|
||
|
* Hash table stuff to maintain proc <-> vm mapping. 23 entries should be
|
||
|
* plenty.. unless someone plans to run more than 23 guest OSs..
|
||
|
*
|
||
|
* Note that a process can only open the device once with this scheme.
|
||
|
*/
|
||
|
|
||
|
LIST_HEAD(plex86_hashhead, plex86_vmentry);
|
||
|
|
||
|
struct plex86_vmentry {
|
||
|
pid_t vm_pid;
|
||
|
vm_t *vm_vm;
|
||
|
LIST_ENTRY(plex86_vmentry) vm_entry;
|
||
|
};
|
||
|
|
||
|
struct plex86_hashhead *plex86_hashtbl;
|
||
|
u_long plex86_hashmask;
|
||
|
|
||
|
#define PLEX86_VMHASHSIZE 23
|
||
|
#define PLEX86_VMHASH(p) ((u_long)((p)->p_pid) & plex86_hashmask)
|
||
|
|
||
|
static int
|
||
|
plex86_open(dev_t dev, int flags, int fmt, struct proc * p)
|
||
|
{
|
||
|
vm_t *vm;
|
||
|
|
||
|
if (suser_xxx(p->p_ucred, p, p->p_acflag) != 0)
|
||
|
return (EPERM);
|
||
|
|
||
|
vm = find_vm(p);
|
||
|
if (vm == NULL) {
|
||
|
vm = malloc(sizeof(vm_t), M_PLEX86, M_WAITOK);
|
||
|
if (vm == NULL)
|
||
|
return EIO;
|
||
|
memset(vm, 0, sizeof(vm_t));
|
||
|
register_vm(vm, p);
|
||
|
plex86sc.sc_open++;
|
||
|
} else
|
||
|
return (EBUSY);
|
||
|
|
||
|
/* Kernel independent device open code. */
|
||
|
hostDeviceOpenInit(vm);
|
||
|
|
||
|
#ifdef FREEBSD_PLEX86_DEBUG
|
||
|
printf("plex86: pid %u opened device, vm %p\n", p->p_pid, vm);
|
||
|
#endif
|
||
|
|
||
|
return (0);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
plex86_close(dev_t dev, int flags, int fmt, struct proc * p)
|
||
|
{
|
||
|
unregister_all(p);
|
||
|
plex86sc.sc_open = 0;
|
||
|
#ifdef FREEBSD_PLEX86_DEBUG
|
||
|
printf("plex86: pid %u closed device\n", p->p_pid);
|
||
|
#endif
|
||
|
return (0);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
plex86_mmap(dev_t dev, vm_offset_t offset, int nprot)
|
||
|
{
|
||
|
struct proc *p = curproc;
|
||
|
int page;
|
||
|
vm_offset_t endguestoff;
|
||
|
vm_t *vm;
|
||
|
|
||
|
vm = find_vm(p);
|
||
|
if (vm == NULL)
|
||
|
return (ENXIO);
|
||
|
|
||
|
#warning "kludge to mmap message buffer"
|
||
|
endguestoff = (vm_offset_t) (vm->pages.guest_n_megs * 1024 * 1024);
|
||
|
if (offset >= endguestoff && nprot == PROT_READ) {
|
||
|
page = (offset - endguestoff) / PAGE_SIZE;
|
||
|
return (vm->pages.log_buffer[page]);
|
||
|
}
|
||
|
page = offset / PAGE_SIZE;
|
||
|
if (page < 0 || page > vm->pages.guest_n_pages) {
|
||
|
log(LOG_WARNING, "plex86: mmap: offset %lx out of range\n",
|
||
|
(unsigned long) offset);
|
||
|
return -1;
|
||
|
}
|
||
|
return vm->pages.guest[page];
|
||
|
}
|
||
|
|
||
|
int
|
||
|
plex86_ioctl(dev_t dev, u_long cmd, caddr_t data, int flags,
|
||
|
struct proc * p)
|
||
|
{
|
||
|
int error;
|
||
|
vm_t *vm;
|
||
|
|
||
|
vm = find_vm(p);
|
||
|
if (vm == NULL)
|
||
|
return EINVAL;
|
||
|
|
||
|
switch (cmd) {
|
||
|
case PLEX86_ALLOCVPHYS:
|
||
|
{
|
||
|
unsigned arg = *((unsigned *) data);
|
||
|
guest_cpu_t guest_cpu;
|
||
|
|
||
|
if (vm->mon_state != MON_STATE_UNINITIALIZED ||
|
||
|
vm->pages.guest_n_megs != 0)
|
||
|
return EBUSY;
|
||
|
if (arg > PLEX86_MAX_PHY_MEGS || arg < 4 || (arg & ~0x3) != arg)
|
||
|
return EINVAL;
|
||
|
|
||
|
/* Allocate memory */
|
||
|
error = allocVmPages(vm, arg);
|
||
|
if (error != 0) {
|
||
|
log(LOG_WARNING, "plex86: allocVmPages failed (%d)\n",
|
||
|
error);
|
||
|
return ENOMEM;
|
||
|
}
|
||
|
if (init_guest_phy_mem(vm) != 0) {
|
||
|
log(LOG_ERR, "plex86: init_guest_phy_mem failed\n");
|
||
|
unallocVmPages(vm);
|
||
|
return EFAULT;
|
||
|
}
|
||
|
getCpuResetValues(&guest_cpu);
|
||
|
log(LOG_WARNING, "plex86: cpu.cr0 = 0x%x\n", guest_cpu.cr0);
|
||
|
if (!init_monitor(vm, 0, 0, &guest_cpu) ||
|
||
|
!setGuestCPU(vm, 0, &guest_cpu) ||
|
||
|
!mapMonitor(vm, guest_cpu.eflags, 0)) {
|
||
|
log(LOG_ERR, "plex86: init_monitor failed\n");
|
||
|
unallocVmPages(vm);
|
||
|
return EFAULT;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case PLEX86_TEARDOWN:
|
||
|
unallocVmPages(vm);
|
||
|
break;
|
||
|
|
||
|
case PLEX86_ALLOCINT:
|
||
|
return EINVAL;
|
||
|
case PLEX86_RELEASEINT:
|
||
|
return EINVAL;
|
||
|
case PLEX86_PRESCANDEPTH:
|
||
|
{
|
||
|
unsigned long arg = *(unsigned long *) data;
|
||
|
|
||
|
if ((arg < PrescanDepthMin) || (arg > PrescanDepthMax)) {
|
||
|
log(LOG_WARNING, "plex86: Requested prescan depth %lu"
|
||
|
" out of range [%u..%u]\n", arg, PrescanDepthMin,
|
||
|
PrescanDepthMax);
|
||
|
return EINVAL;
|
||
|
}
|
||
|
vm->prescanDepth = (unsigned) arg;
|
||
|
break;
|
||
|
}
|
||
|
case PLEX86_SETINTR:
|
||
|
ioctlSetIntr(vm, *(unsigned long *) data);
|
||
|
break;
|
||
|
case PLEX86_SET_A20:
|
||
|
{
|
||
|
unsigned long arg = *(unsigned long *) data;
|
||
|
if (!ioctlSetA20E(vm, arg))
|
||
|
return EINVAL;
|
||
|
break;
|
||
|
}
|
||
|
case PLEX86_MESSAGEQ:
|
||
|
{
|
||
|
vm_messages_t msg;
|
||
|
|
||
|
if (vm->mon_state != MON_STATE_RUNNABLE)
|
||
|
return EINVAL;
|
||
|
|
||
|
error = copyin(*(void **) data, &msg.header, sizeof msg.header);
|
||
|
if (error != 0)
|
||
|
return error;
|
||
|
|
||
|
if ((msg.header.msg_len + sizeof(msg.header)) > sizeof(msg))
|
||
|
return EINVAL;
|
||
|
|
||
|
if (msg.header.msg_len != 0) {
|
||
|
error = copyin(&((vm_messages_t *) * (void **) data)->msg,
|
||
|
&msg.msg, msg.header.msg_len);
|
||
|
if (error != 0)
|
||
|
return error;
|
||
|
}
|
||
|
if (ioctlMessageQ(vm, &msg)) {
|
||
|
log(LOG_WARNING, "plex86: ioctlMessageQ failed\n");
|
||
|
return EINVAL;
|
||
|
}
|
||
|
error = copyout(&msg, *(void **) data,
|
||
|
sizeof(msg.header) + msg.header.msg_len);
|
||
|
return error;
|
||
|
}
|
||
|
case PLEX86_RESET:
|
||
|
break;
|
||
|
|
||
|
case PLEX86_PHYMEM_MOD:
|
||
|
break;
|
||
|
case PLEX86_FORCE_INT:
|
||
|
if (vm->mon_state != MON_STATE_RUNNABLE)
|
||
|
return -EINVAL;
|
||
|
vm->dbg_force_int = 0x100 | (unsigned) data;
|
||
|
break;
|
||
|
case PLEX86_PRESCANRING3:
|
||
|
{
|
||
|
unsigned long arg = *(unsigned long *) data;
|
||
|
if (arg > PrescanRing3On) {
|
||
|
log(LOG_WARNING,
|
||
|
"plex86: Requested PrescanRing3 val(%lu) OOB\n",
|
||
|
arg);
|
||
|
return EINVAL;
|
||
|
}
|
||
|
vm->prescanRing3 = arg;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
default:
|
||
|
log(LOG_WARNING, "plex86: unknown ioctl %lx\n", cmd);
|
||
|
return EINVAL;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
register_vm(vm_t * vm, struct proc * p)
|
||
|
{
|
||
|
struct plex86_hashhead *php;
|
||
|
struct plex86_vmentry *vhp;
|
||
|
|
||
|
php = &plex86_hashtbl[PLEX86_VMHASH(p)];
|
||
|
#if DIAGNOSTIC
|
||
|
for (vhp = php->lh_first; vhp != NULL; vhp = vhp->vm_entry.le_next) {
|
||
|
if (vhp->vm_pid == p->p_pid)
|
||
|
panic("plex86: vm already registered, pid %u\n",
|
||
|
p->p_pid);
|
||
|
}
|
||
|
#endif
|
||
|
vhp = malloc(sizeof(struct plex86_vmentry), M_PLEX86, M_WAITOK);
|
||
|
vhp->vm_pid = p->p_pid;
|
||
|
vhp->vm_vm = vm;
|
||
|
LIST_INSERT_HEAD(php, vhp, vm_entry);
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
unregister_vm(vm_t * vm, struct proc * p)
|
||
|
{
|
||
|
struct plex86_hashhead *php;
|
||
|
struct plex86_vmentry *vhp;
|
||
|
|
||
|
php = &plex86_hashtbl[PLEX86_VMHASH(p)];
|
||
|
for (vhp = php->lh_first; vhp != NULL; vhp = vhp->vm_entry.le_next) {
|
||
|
if (vhp->vm_pid == p->p_pid) {
|
||
|
LIST_REMOVE(vhp, vm_entry);
|
||
|
free(vhp->vm_vm, M_PLEX86);
|
||
|
free(vhp, M_PLEX86);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
unregister_all(struct proc * p)
|
||
|
{
|
||
|
int i;
|
||
|
struct plex86_hashhead *php;
|
||
|
struct plex86_vmentry *vhp;
|
||
|
|
||
|
php = &plex86_hashtbl[PLEX86_VMHASH(p)];
|
||
|
if (php == NULL)
|
||
|
return;
|
||
|
for (vhp = php->lh_first; vhp != NULL;
|
||
|
vhp = vhp->vm_entry.le_next) {
|
||
|
#ifdef FREEBSD_PLEX86_DEBUG
|
||
|
printf("plex86: unregister vm %p, pid %u\n",
|
||
|
vhp->vm_vm, vhp->vm_pid);
|
||
|
#endif
|
||
|
LIST_REMOVE(vhp, vm_entry);
|
||
|
if (vhp->vm_vm != NULL)
|
||
|
free(vhp->vm_vm, M_PLEX86);
|
||
|
if (vhp != NULL)
|
||
|
free(vhp, M_PLEX86);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static vm_t *
|
||
|
find_vm(struct proc * p)
|
||
|
{
|
||
|
struct plex86_hashhead *php;
|
||
|
struct plex86_vmentry *vhp;
|
||
|
|
||
|
php = &plex86_hashtbl[PLEX86_VMHASH(p)];
|
||
|
for (vhp = php->lh_first; vhp != NULL; vhp = vhp->vm_entry.le_next) {
|
||
|
if (vhp->vm_pid == p->p_pid)
|
||
|
return vhp->vm_vm;
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
static unsigned
|
||
|
retrieve_phy_pages(Bit32u * page, int max_pages, void *addr_v, unsigned size,
|
||
|
int aligned)
|
||
|
{
|
||
|
Bit32u start_addr;
|
||
|
unsigned n_pages, i;
|
||
|
|
||
|
if (!aligned)
|
||
|
start_addr = (Bit32u) addr_v & ~(PAGE_SIZE - 1);
|
||
|
else {
|
||
|
start_addr = (Bit32u) addr_v;
|
||
|
if (start_addr & (PAGE_SIZE - 1)) {
|
||
|
log(LOG_WARNING, "plex86: retrieve_phy_pages: address "
|
||
|
"%p not aligned\n", addr_v);
|
||
|
return 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
n_pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
|
||
|
if (n_pages > max_pages) {
|
||
|
log(LOG_WARNING, "plex86: retrieve_phy_pages: page list "
|
||
|
"too small\n");
|
||
|
return (0);
|
||
|
}
|
||
|
for (i = 0; i < n_pages; i++) {
|
||
|
page[i] = kvtop((vm_offset_t) start_addr) / PAGE_SIZE;
|
||
|
start_addr += PAGE_SIZE;
|
||
|
}
|
||
|
|
||
|
return n_pages;
|
||
|
}
|
||
|
|
||
|
unsigned
|
||
|
host_idle(void)
|
||
|
{
|
||
|
#if defined(want_resched)
|
||
|
if (want_resched) {
|
||
|
#endif
|
||
|
yield(curproc, NULL); /* XXX */
|
||
|
need_resched(); /* XXX */
|
||
|
#if defined(want_resched)
|
||
|
}
|
||
|
#endif
|
||
|
printf("resched done\n");
|
||
|
return (CURSIG(curproc) == 0);
|
||
|
}
|
||
|
|
||
|
void *
|
||
|
host_alloc(unsigned long size)
|
||
|
{
|
||
|
/*
|
||
|
* XXX - it wants this page-aligned apparently.
|
||
|
*/
|
||
|
if (size <= (PAGE_SIZE / 2))
|
||
|
size = PAGE_SIZE;
|
||
|
return (malloc(size, M_PLEX86, M_WAITOK));
|
||
|
}
|
||
|
|
||
|
void
|
||
|
host_free(void *ptr)
|
||
|
{
|
||
|
free(ptr, M_PLEX86);
|
||
|
}
|
||
|
|
||
|
unsigned
|
||
|
host_map(Bit32u * page, int max_pages, void *ptr, unsigned size)
|
||
|
{
|
||
|
return retrieve_phy_pages(page, max_pages, ptr, size, 1);
|
||
|
}
|
||
|
|
||
|
void *
|
||
|
host_alloc_page(void)
|
||
|
{
|
||
|
return malloc(PAGE_SIZE, M_PLEX86, M_WAITOK);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
host_free_page(void *ptr)
|
||
|
{
|
||
|
return free(ptr, M_PLEX86);
|
||
|
}
|
||
|
|
||
|
Bit32u
|
||
|
host_map_page(void *ptr)
|
||
|
{
|
||
|
Bit32u u;
|
||
|
|
||
|
if (ptr == NULL)
|
||
|
return 0;
|
||
|
u = kvtop(ptr) / PAGE_SIZE;
|
||
|
#if FREEBSD_PLEX86_DEBUG
|
||
|
printf("host_map_page(%p) -> %x\n", ptr, u);
|
||
|
#endif
|
||
|
return u;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hostprint(char *fmt,...)
|
||
|
{
|
||
|
va_list args;
|
||
|
int ret;
|
||
|
unsigned char buffer[256];
|
||
|
|
||
|
va_start(args, fmt);
|
||
|
ret = vsnprintf(buffer, 256, fmt, args);
|
||
|
if (ret == -1)
|
||
|
log(LOG_WARNING,
|
||
|
"plex86: hostprint: vsnprintf returns error.\n");
|
||
|
else
|
||
|
log(LOG_WARNING, "plex86: %s\n", buffer);
|
||
|
}
|
||
|
|
||
|
static int
|
||
|
plex86_modevent(module_t mod, int type, void *data)
|
||
|
{
|
||
|
linker_file_t lf;
|
||
|
int error = 0;
|
||
|
|
||
|
switch (type) {
|
||
|
case MOD_LOAD:
|
||
|
plex86_hashtbl = NULL;
|
||
|
|
||
|
lf = linker_find_file_by_name("plex86");
|
||
|
if (lf == NULL) {
|
||
|
printf("plex86: can't find linker_file 'plex86'\n");
|
||
|
return (ENXIO);
|
||
|
}
|
||
|
monitor_pages.startOffset = lf->address;
|
||
|
monitor_pages.startOffsetPageAligned =
|
||
|
monitor_pages.startOffset & 0xfffff000;
|
||
|
|
||
|
if ((monitor_pages.n_pages = retrieve_phy_pages(monitor_pages.page,
|
||
|
PLEX86_MAX_MONITOR_PAGES,
|
||
|
lf->address,
|
||
|
lf->size,
|
||
|
0)) == 0) {
|
||
|
log(LOG_WARNING, "plex86: could not store physical "
|
||
|
"addresses for monitor pages\n");
|
||
|
return (ENXIO);
|
||
|
}
|
||
|
plex86_hashtbl = hashinit(PLEX86_VMHASHSIZE,
|
||
|
M_PLEX86, &plex86_hashmask);
|
||
|
|
||
|
if (!hostModuleInit()) {
|
||
|
log(LOG_WARNING, "hostModuleInit error\n");
|
||
|
error = EINVAL;
|
||
|
}
|
||
|
|
||
|
plex86_dev = make_dev(&plex86_cdevsw, 0 /* minor */ , UID_ROOT,
|
||
|
GID_WHEEL, 0600, "plex86");
|
||
|
|
||
|
printf("plex86: Module loaded.\n");
|
||
|
return (0);
|
||
|
break;
|
||
|
case MOD_UNLOAD:
|
||
|
if (plex86sc.sc_open != 0)
|
||
|
return (EBUSY);
|
||
|
|
||
|
destroy_dev(plex86_dev);
|
||
|
|
||
|
if (plex86_hashtbl != NULL) {
|
||
|
free(plex86_hashtbl, M_PLEX86);
|
||
|
}
|
||
|
printf("plex86: Module unloaded.\n");
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
error = ENXIO;
|
||
|
break;
|
||
|
}
|
||
|
return (error);
|
||
|
}
|
||
|
|
||
|
MODULE_VERSION(plex86, 1);
|
||
|
DEV_MODULE(plex86, plex86_modevent, 0);
|