4d4a8c96e3
Signed-off-by: Vladimir Serbinenko <phcoder@gmail.com> Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com> Reviewed-by: Ross Philipson <ross.philipson@oracle.com>
978 lines
28 KiB
C
978 lines
28 KiB
C
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2013 Free Software Foundation, Inc.
|
|
*
|
|
* GRUB is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GRUB 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <grub/loader.h>
|
|
#include <grub/memory.h>
|
|
#include <grub/normal.h>
|
|
#include <grub/file.h>
|
|
#include <grub/disk.h>
|
|
#include <grub/err.h>
|
|
#include <grub/misc.h>
|
|
#include <grub/types.h>
|
|
#include <grub/dl.h>
|
|
#include <grub/mm.h>
|
|
#include <grub/term.h>
|
|
#include <grub/cpu/linux.h>
|
|
#include <grub/video.h>
|
|
#include <grub/video_fb.h>
|
|
#include <grub/command.h>
|
|
#include <grub/xen/relocator.h>
|
|
#include <grub/i18n.h>
|
|
#include <grub/elf.h>
|
|
#include <grub/elfload.h>
|
|
#include <grub/lib/cmdline.h>
|
|
#include <grub/xen.h>
|
|
#include <grub/xen_file.h>
|
|
#include <grub/linux.h>
|
|
#include <grub/i386/memory.h>
|
|
#include <grub/verify.h>
|
|
|
|
GRUB_MOD_LICENSE ("GPLv3+");
|
|
|
|
#ifdef __x86_64__
|
|
#define NUMBER_OF_LEVELS 4
|
|
#define INTERMEDIATE_OR (GRUB_PAGE_PRESENT | GRUB_PAGE_RW | GRUB_PAGE_USER)
|
|
#define VIRT_MASK 0x0000ffffffffffffULL
|
|
#else
|
|
#define NUMBER_OF_LEVELS 3
|
|
#define INTERMEDIATE_OR (GRUB_PAGE_PRESENT | GRUB_PAGE_RW)
|
|
#define VIRT_MASK 0x00000000ffffffffULL
|
|
#define HYPERVISOR_PUD_ADDRESS 0xc0000000ULL
|
|
#endif
|
|
|
|
struct grub_xen_mapping_lvl {
|
|
grub_uint64_t virt_start;
|
|
grub_uint64_t virt_end;
|
|
grub_uint64_t pfn_start;
|
|
grub_uint64_t n_pt_pages;
|
|
};
|
|
|
|
struct grub_xen_mapping {
|
|
grub_uint64_t *where;
|
|
struct grub_xen_mapping_lvl area;
|
|
struct grub_xen_mapping_lvl lvls[NUMBER_OF_LEVELS];
|
|
};
|
|
|
|
struct xen_loader_state {
|
|
struct grub_relocator *relocator;
|
|
struct grub_relocator_xen_state state;
|
|
struct start_info next_start;
|
|
struct grub_xen_file_info xen_inf;
|
|
grub_xen_mfn_t *virt_mfn_list;
|
|
struct start_info *virt_start_info;
|
|
grub_xen_mfn_t console_pfn;
|
|
grub_uint64_t max_addr;
|
|
grub_uint64_t pgtbl_end;
|
|
struct xen_multiboot_mod_list *module_info_page;
|
|
grub_uint64_t modules_target_start;
|
|
grub_size_t n_modules;
|
|
struct grub_xen_mapping *map_reloc;
|
|
struct grub_xen_mapping mappings[XEN_MAX_MAPPINGS];
|
|
int n_mappings;
|
|
int loaded;
|
|
};
|
|
|
|
static struct xen_loader_state xen_state;
|
|
|
|
static grub_dl_t my_mod;
|
|
|
|
#define PAGE_SIZE (1UL << PAGE_SHIFT)
|
|
#define MAX_MODULES (PAGE_SIZE / sizeof (struct xen_multiboot_mod_list))
|
|
#define STACK_SIZE 1048576
|
|
#define ADDITIONAL_SIZE (1 << 19)
|
|
#define ALIGN_SIZE (1 << 22)
|
|
#define LOG_POINTERS_PER_PAGE 9
|
|
#define POINTERS_PER_PAGE (1 << LOG_POINTERS_PER_PAGE)
|
|
|
|
static grub_uint64_t
|
|
page2offset (grub_uint64_t page)
|
|
{
|
|
return page << PAGE_SHIFT;
|
|
}
|
|
|
|
static grub_err_t
|
|
get_pgtable_size (grub_uint64_t from, grub_uint64_t to, grub_uint64_t pfn)
|
|
{
|
|
struct grub_xen_mapping *map, *map_cmp;
|
|
grub_uint64_t mask, bits;
|
|
int i, m;
|
|
|
|
if (xen_state.n_mappings == XEN_MAX_MAPPINGS)
|
|
return grub_error (GRUB_ERR_BUG, "too many mapped areas");
|
|
|
|
grub_dprintf ("xen", "get_pgtable_size %d from=%llx, to=%llx, pfn=%llx\n",
|
|
xen_state.n_mappings, (unsigned long long) from,
|
|
(unsigned long long) to, (unsigned long long) pfn);
|
|
|
|
map = xen_state.mappings + xen_state.n_mappings;
|
|
grub_memset (map, 0, sizeof (*map));
|
|
|
|
map->area.virt_start = from & VIRT_MASK;
|
|
map->area.virt_end = (to - 1) & VIRT_MASK;
|
|
map->area.n_pt_pages = 0;
|
|
|
|
for (i = NUMBER_OF_LEVELS - 1; i >= 0; i--)
|
|
{
|
|
map->lvls[i].pfn_start = pfn + map->area.n_pt_pages;
|
|
if (i == NUMBER_OF_LEVELS - 1)
|
|
{
|
|
if (xen_state.n_mappings == 0)
|
|
{
|
|
map->lvls[i].virt_start = 0;
|
|
map->lvls[i].virt_end = VIRT_MASK;
|
|
map->lvls[i].n_pt_pages = 1;
|
|
map->area.n_pt_pages++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
bits = PAGE_SHIFT + (i + 1) * LOG_POINTERS_PER_PAGE;
|
|
mask = (1ULL << bits) - 1;
|
|
map->lvls[i].virt_start = map->area.virt_start & ~mask;
|
|
map->lvls[i].virt_end = map->area.virt_end | mask;
|
|
#ifdef __i386__
|
|
/* PAE wants last root directory present. */
|
|
if (i == 1 && to <= HYPERVISOR_PUD_ADDRESS && xen_state.n_mappings == 0)
|
|
map->lvls[i].virt_end = VIRT_MASK;
|
|
#endif
|
|
for (m = 0; m < xen_state.n_mappings; m++)
|
|
{
|
|
map_cmp = xen_state.mappings + m;
|
|
if (map_cmp->lvls[i].virt_start == map_cmp->lvls[i].virt_end)
|
|
continue;
|
|
if (map->lvls[i].virt_start >= map_cmp->lvls[i].virt_start &&
|
|
map->lvls[i].virt_end <= map_cmp->lvls[i].virt_end)
|
|
{
|
|
map->lvls[i].virt_start = 0;
|
|
map->lvls[i].virt_end = 0;
|
|
break;
|
|
}
|
|
if (map->lvls[i].virt_start >= map_cmp->lvls[i].virt_start &&
|
|
map->lvls[i].virt_start <= map_cmp->lvls[i].virt_end)
|
|
map->lvls[i].virt_start = map_cmp->lvls[i].virt_end + 1;
|
|
if (map->lvls[i].virt_end >= map_cmp->lvls[i].virt_start &&
|
|
map->lvls[i].virt_end <= map_cmp->lvls[i].virt_end)
|
|
map->lvls[i].virt_end = map_cmp->lvls[i].virt_start - 1;
|
|
}
|
|
if (map->lvls[i].virt_start < map->lvls[i].virt_end)
|
|
map->lvls[i].n_pt_pages =
|
|
((map->lvls[i].virt_end - map->lvls[i].virt_start) >> bits) + 1;
|
|
map->area.n_pt_pages += map->lvls[i].n_pt_pages;
|
|
grub_dprintf ("xen", "get_pgtable_size level %d: virt %llx-%llx %d pts\n",
|
|
i, (unsigned long long) map->lvls[i].virt_start,
|
|
(unsigned long long) map->lvls[i].virt_end,
|
|
(int) map->lvls[i].n_pt_pages);
|
|
}
|
|
|
|
grub_dprintf ("xen", "get_pgtable_size return: %d page tables\n",
|
|
(int) map->area.n_pt_pages);
|
|
|
|
xen_state.state.paging_start[xen_state.n_mappings] = pfn;
|
|
xen_state.state.paging_size[xen_state.n_mappings] = map->area.n_pt_pages;
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_uint64_t *
|
|
get_pg_table_virt (int mapping, int level)
|
|
{
|
|
grub_uint64_t pfn;
|
|
struct grub_xen_mapping *map;
|
|
|
|
map = xen_state.mappings + mapping;
|
|
pfn = map->lvls[level].pfn_start - map->lvls[NUMBER_OF_LEVELS - 1].pfn_start;
|
|
return map->where + pfn * POINTERS_PER_PAGE;
|
|
}
|
|
|
|
static grub_uint64_t
|
|
get_pg_table_prot (int level, grub_uint64_t pfn)
|
|
{
|
|
int m;
|
|
grub_uint64_t pfn_s, pfn_e;
|
|
|
|
if (level > 0)
|
|
return INTERMEDIATE_OR;
|
|
for (m = 0; m < xen_state.n_mappings; m++)
|
|
{
|
|
pfn_s = xen_state.mappings[m].lvls[NUMBER_OF_LEVELS - 1].pfn_start;
|
|
pfn_e = xen_state.mappings[m].area.n_pt_pages + pfn_s;
|
|
if (pfn >= pfn_s && pfn < pfn_e)
|
|
return GRUB_PAGE_PRESENT | GRUB_PAGE_USER;
|
|
}
|
|
return GRUB_PAGE_PRESENT | GRUB_PAGE_RW | GRUB_PAGE_USER;
|
|
}
|
|
|
|
static void
|
|
generate_page_table (grub_xen_mfn_t *mfn_list)
|
|
{
|
|
int l, m1, m2;
|
|
long p, p_s, p_e;
|
|
grub_uint64_t start, end, pfn;
|
|
grub_uint64_t *pg;
|
|
struct grub_xen_mapping_lvl *lvl;
|
|
|
|
for (m1 = 0; m1 < xen_state.n_mappings; m1++)
|
|
grub_memset (xen_state.mappings[m1].where, 0,
|
|
xen_state.mappings[m1].area.n_pt_pages * PAGE_SIZE);
|
|
|
|
for (l = NUMBER_OF_LEVELS - 1; l >= 0; l--)
|
|
{
|
|
for (m1 = 0; m1 < xen_state.n_mappings; m1++)
|
|
{
|
|
start = xen_state.mappings[m1].lvls[l].virt_start;
|
|
end = xen_state.mappings[m1].lvls[l].virt_end;
|
|
pg = get_pg_table_virt(m1, l);
|
|
for (m2 = 0; m2 < xen_state.n_mappings; m2++)
|
|
{
|
|
lvl = (l > 0) ? xen_state.mappings[m2].lvls + l - 1
|
|
: &xen_state.mappings[m2].area;
|
|
if (l > 0 && lvl->n_pt_pages == 0)
|
|
continue;
|
|
if (lvl->virt_start >= end || lvl->virt_end <= start)
|
|
continue;
|
|
p_s = (grub_max (start, lvl->virt_start) - start) >>
|
|
(PAGE_SHIFT + l * LOG_POINTERS_PER_PAGE);
|
|
p_e = (grub_min (end, lvl->virt_end) - start) >>
|
|
(PAGE_SHIFT + l * LOG_POINTERS_PER_PAGE);
|
|
pfn = ((grub_max (start, lvl->virt_start) - lvl->virt_start) >>
|
|
(PAGE_SHIFT + l * LOG_POINTERS_PER_PAGE)) + lvl->pfn_start;
|
|
grub_dprintf ("xen", "write page table entries level %d pg %p "
|
|
"mapping %d/%d index %lx-%lx pfn %llx\n",
|
|
l, pg, m1, m2, p_s, p_e, (unsigned long long) pfn);
|
|
for (p = p_s; p <= p_e; p++)
|
|
{
|
|
pg[p] = page2offset (mfn_list[pfn]) |
|
|
get_pg_table_prot (l, pfn);
|
|
pfn++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static grub_err_t
|
|
set_mfns (grub_xen_mfn_t pfn)
|
|
{
|
|
grub_xen_mfn_t i, t;
|
|
grub_xen_mfn_t cn_pfn = -1, st_pfn = -1;
|
|
struct mmu_update m2p_updates[4];
|
|
|
|
|
|
for (i = 0; i < grub_xen_start_page_addr->nr_pages; i++)
|
|
{
|
|
if (xen_state.virt_mfn_list[i] ==
|
|
grub_xen_start_page_addr->console.domU.mfn)
|
|
cn_pfn = i;
|
|
if (xen_state.virt_mfn_list[i] == grub_xen_start_page_addr->store_mfn)
|
|
st_pfn = i;
|
|
}
|
|
if (cn_pfn == (grub_xen_mfn_t)-1)
|
|
return grub_error (GRUB_ERR_BUG, "no console");
|
|
if (st_pfn == (grub_xen_mfn_t)-1)
|
|
return grub_error (GRUB_ERR_BUG, "no store");
|
|
t = xen_state.virt_mfn_list[pfn];
|
|
xen_state.virt_mfn_list[pfn] = xen_state.virt_mfn_list[cn_pfn];
|
|
xen_state.virt_mfn_list[cn_pfn] = t;
|
|
t = xen_state.virt_mfn_list[pfn + 1];
|
|
xen_state.virt_mfn_list[pfn + 1] = xen_state.virt_mfn_list[st_pfn];
|
|
xen_state.virt_mfn_list[st_pfn] = t;
|
|
|
|
m2p_updates[0].ptr =
|
|
page2offset (xen_state.virt_mfn_list[pfn]) | MMU_MACHPHYS_UPDATE;
|
|
m2p_updates[0].val = pfn;
|
|
m2p_updates[1].ptr =
|
|
page2offset (xen_state.virt_mfn_list[pfn + 1]) | MMU_MACHPHYS_UPDATE;
|
|
m2p_updates[1].val = pfn + 1;
|
|
m2p_updates[2].ptr =
|
|
page2offset (xen_state.virt_mfn_list[cn_pfn]) | MMU_MACHPHYS_UPDATE;
|
|
m2p_updates[2].val = cn_pfn;
|
|
m2p_updates[3].ptr =
|
|
page2offset (xen_state.virt_mfn_list[st_pfn]) | MMU_MACHPHYS_UPDATE;
|
|
m2p_updates[3].val = st_pfn;
|
|
|
|
grub_xen_mmu_update (m2p_updates, 4, NULL, DOMID_SELF);
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_xen_p2m_alloc (void)
|
|
{
|
|
grub_relocator_chunk_t ch;
|
|
grub_size_t p2msize, p2malloc;
|
|
grub_err_t err;
|
|
struct grub_xen_mapping *map;
|
|
|
|
if (xen_state.virt_mfn_list)
|
|
return GRUB_ERR_NONE;
|
|
|
|
map = xen_state.mappings + xen_state.n_mappings;
|
|
p2msize = ALIGN_UP (sizeof (grub_xen_mfn_t) *
|
|
grub_xen_start_page_addr->nr_pages, PAGE_SIZE);
|
|
if (xen_state.xen_inf.has_p2m_base)
|
|
{
|
|
err = get_pgtable_size (xen_state.xen_inf.p2m_base,
|
|
xen_state.xen_inf.p2m_base + p2msize,
|
|
(xen_state.max_addr + p2msize) >> PAGE_SHIFT);
|
|
if (err)
|
|
return err;
|
|
|
|
map->area.pfn_start = xen_state.max_addr >> PAGE_SHIFT;
|
|
p2malloc = p2msize + page2offset (map->area.n_pt_pages);
|
|
xen_state.n_mappings++;
|
|
xen_state.next_start.mfn_list = xen_state.xen_inf.p2m_base;
|
|
xen_state.next_start.first_p2m_pfn = map->area.pfn_start;
|
|
xen_state.next_start.nr_p2m_frames = p2malloc >> PAGE_SHIFT;
|
|
}
|
|
else
|
|
{
|
|
xen_state.next_start.mfn_list =
|
|
xen_state.max_addr + xen_state.xen_inf.virt_base;
|
|
p2malloc = p2msize;
|
|
}
|
|
|
|
xen_state.state.mfn_list = xen_state.max_addr;
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr, p2malloc);
|
|
if (err)
|
|
return err;
|
|
xen_state.virt_mfn_list = get_virtual_current_address (ch);
|
|
if (xen_state.xen_inf.has_p2m_base)
|
|
map->where = (grub_uint64_t *) xen_state.virt_mfn_list +
|
|
p2msize / sizeof (grub_uint64_t);
|
|
grub_memcpy (xen_state.virt_mfn_list,
|
|
(void *) grub_xen_start_page_addr->mfn_list, p2msize);
|
|
xen_state.max_addr += p2malloc;
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_xen_special_alloc (void)
|
|
{
|
|
grub_relocator_chunk_t ch;
|
|
grub_err_t err;
|
|
|
|
if (xen_state.virt_start_info)
|
|
return GRUB_ERR_NONE;
|
|
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr,
|
|
sizeof (xen_state.next_start));
|
|
if (err)
|
|
return err;
|
|
xen_state.state.start_info = xen_state.max_addr + xen_state.xen_inf.virt_base;
|
|
xen_state.virt_start_info = get_virtual_current_address (ch);
|
|
xen_state.max_addr =
|
|
ALIGN_UP (xen_state.max_addr + sizeof (xen_state.next_start), PAGE_SIZE);
|
|
xen_state.console_pfn = xen_state.max_addr >> PAGE_SHIFT;
|
|
xen_state.max_addr += 2 * PAGE_SIZE;
|
|
|
|
xen_state.next_start.nr_pages = grub_xen_start_page_addr->nr_pages;
|
|
grub_memcpy (xen_state.next_start.magic, grub_xen_start_page_addr->magic,
|
|
sizeof (xen_state.next_start.magic));
|
|
xen_state.next_start.store_mfn = grub_xen_start_page_addr->store_mfn;
|
|
xen_state.next_start.store_evtchn = grub_xen_start_page_addr->store_evtchn;
|
|
xen_state.next_start.console.domU = grub_xen_start_page_addr->console.domU;
|
|
xen_state.next_start.shared_info = grub_xen_start_page_addr->shared_info;
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_xen_pt_alloc (void)
|
|
{
|
|
grub_relocator_chunk_t ch;
|
|
grub_err_t err;
|
|
grub_uint64_t nr_info_pages;
|
|
grub_uint64_t nr_need_pages;
|
|
grub_uint64_t try_virt_end;
|
|
struct grub_xen_mapping *map;
|
|
|
|
if (xen_state.pgtbl_end)
|
|
return GRUB_ERR_NONE;
|
|
|
|
map = xen_state.mappings + xen_state.n_mappings;
|
|
xen_state.map_reloc = map + 1;
|
|
|
|
xen_state.next_start.pt_base =
|
|
xen_state.max_addr + xen_state.xen_inf.virt_base;
|
|
nr_info_pages = xen_state.max_addr >> PAGE_SHIFT;
|
|
nr_need_pages = nr_info_pages;
|
|
|
|
while (1)
|
|
{
|
|
try_virt_end = ALIGN_UP (xen_state.xen_inf.virt_base +
|
|
page2offset (nr_need_pages) +
|
|
ADDITIONAL_SIZE + STACK_SIZE, ALIGN_SIZE);
|
|
|
|
err = get_pgtable_size (xen_state.xen_inf.virt_base, try_virt_end,
|
|
nr_info_pages);
|
|
if (err)
|
|
return err;
|
|
xen_state.n_mappings++;
|
|
|
|
/* Map the relocator page either at virtual 0 or after end of area. */
|
|
nr_need_pages = nr_info_pages + map->area.n_pt_pages;
|
|
if (xen_state.xen_inf.virt_base)
|
|
err = get_pgtable_size (0, PAGE_SIZE, nr_need_pages);
|
|
else
|
|
err = get_pgtable_size (try_virt_end, try_virt_end + PAGE_SIZE,
|
|
nr_need_pages);
|
|
if (err)
|
|
return err;
|
|
nr_need_pages += xen_state.map_reloc->area.n_pt_pages;
|
|
|
|
if (xen_state.xen_inf.virt_base + page2offset (nr_need_pages) <=
|
|
try_virt_end)
|
|
break;
|
|
|
|
xen_state.n_mappings--;
|
|
}
|
|
|
|
xen_state.n_mappings++;
|
|
nr_need_pages = map->area.n_pt_pages + xen_state.map_reloc->area.n_pt_pages;
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr,
|
|
page2offset (nr_need_pages));
|
|
if (err)
|
|
return err;
|
|
|
|
map->where = get_virtual_current_address (ch);
|
|
map->area.pfn_start = 0;
|
|
xen_state.max_addr += page2offset (nr_need_pages);
|
|
xen_state.state.stack =
|
|
xen_state.max_addr + STACK_SIZE + xen_state.xen_inf.virt_base;
|
|
xen_state.next_start.nr_pt_frames = nr_need_pages;
|
|
xen_state.max_addr = try_virt_end - xen_state.xen_inf.virt_base;
|
|
xen_state.pgtbl_end = xen_state.max_addr >> PAGE_SHIFT;
|
|
xen_state.map_reloc->where = (grub_uint64_t *) ((char *) map->where +
|
|
page2offset (map->area.n_pt_pages));
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
/* Allocate all not yet allocated areas mapped by initial page tables. */
|
|
static grub_err_t
|
|
grub_xen_alloc_boot_data (void)
|
|
{
|
|
grub_err_t err;
|
|
|
|
if (!xen_state.xen_inf.has_p2m_base)
|
|
{
|
|
err = grub_xen_p2m_alloc ();
|
|
if (err)
|
|
return err;
|
|
}
|
|
err = grub_xen_special_alloc ();
|
|
if (err)
|
|
return err;
|
|
err = grub_xen_pt_alloc ();
|
|
if (err)
|
|
return err;
|
|
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_xen_boot (void)
|
|
{
|
|
grub_err_t err;
|
|
grub_uint64_t nr_pages;
|
|
struct gnttab_set_version gnttab_setver;
|
|
grub_size_t i;
|
|
|
|
if (grub_xen_n_allocated_shared_pages)
|
|
return grub_error (GRUB_ERR_BUG, "active grants");
|
|
|
|
err = grub_xen_alloc_boot_data ();
|
|
if (err)
|
|
return err;
|
|
if (xen_state.xen_inf.has_p2m_base)
|
|
{
|
|
err = grub_xen_p2m_alloc ();
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
err = set_mfns (xen_state.console_pfn);
|
|
if (err)
|
|
return err;
|
|
|
|
nr_pages = xen_state.max_addr >> PAGE_SHIFT;
|
|
|
|
grub_dprintf ("xen", "bootstrap domain %llx+%llx\n",
|
|
(unsigned long long) xen_state.xen_inf.virt_base,
|
|
(unsigned long long) page2offset (nr_pages));
|
|
|
|
xen_state.map_reloc->area.pfn_start = nr_pages;
|
|
generate_page_table (xen_state.virt_mfn_list);
|
|
|
|
xen_state.state.entry_point = xen_state.xen_inf.entry_point;
|
|
|
|
*xen_state.virt_start_info = xen_state.next_start;
|
|
|
|
grub_memset (&gnttab_setver, 0, sizeof (gnttab_setver));
|
|
|
|
gnttab_setver.version = 1;
|
|
grub_xen_grant_table_op (GNTTABOP_set_version, &gnttab_setver, 1);
|
|
|
|
for (i = 0; i < ARRAY_SIZE (grub_xen_shared_info->evtchn_pending); i++)
|
|
grub_xen_shared_info->evtchn_pending[i] = 0;
|
|
|
|
return grub_relocator_xen_boot (xen_state.relocator, xen_state.state, nr_pages,
|
|
xen_state.xen_inf.virt_base <
|
|
PAGE_SIZE ? page2offset (nr_pages) : 0,
|
|
xen_state.pgtbl_end - 1,
|
|
page2offset (xen_state.pgtbl_end - 1) +
|
|
xen_state.xen_inf.virt_base);
|
|
}
|
|
|
|
static void
|
|
grub_xen_reset (void)
|
|
{
|
|
grub_relocator_unload (xen_state.relocator);
|
|
|
|
grub_memset (&xen_state, 0, sizeof (xen_state));
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_xen_unload (void)
|
|
{
|
|
grub_xen_reset ();
|
|
grub_dl_unref (my_mod);
|
|
return GRUB_ERR_NONE;
|
|
}
|
|
|
|
#define HYPERCALL_INTERFACE_SIZE 32
|
|
|
|
#ifdef __x86_64__
|
|
static grub_uint8_t template[] =
|
|
{
|
|
0x51, /* push %rcx */
|
|
0x41, 0x53, /* push %r11 */
|
|
0x48, 0xc7, 0xc0, 0xbb, 0xaa, 0x00, 0x00, /* mov $0xaabb,%rax */
|
|
0x0f, 0x05, /* syscall */
|
|
0x41, 0x5b, /* pop %r11 */
|
|
0x59, /* pop %rcx */
|
|
0xc3 /* ret */
|
|
};
|
|
|
|
static grub_uint8_t template_iret[] =
|
|
{
|
|
0x51, /* push %rcx */
|
|
0x41, 0x53, /* push %r11 */
|
|
0x50, /* push %rax */
|
|
0x48, 0xc7, 0xc0, 0x17, 0x00, 0x00, 0x00, /* mov $0x17,%rax */
|
|
0x0f, 0x05 /* syscall */
|
|
};
|
|
#define CALLNO_OFFSET 6
|
|
#else
|
|
|
|
static grub_uint8_t template[] =
|
|
{
|
|
0xb8, 0xbb, 0xaa, 0x00, 0x00, /* mov imm32, %eax */
|
|
0xcd, 0x82, /* int $0x82 */
|
|
0xc3 /* ret */
|
|
};
|
|
|
|
static grub_uint8_t template_iret[] =
|
|
{
|
|
0x50, /* push %eax */
|
|
0xb8, 0x17, 0x00, 0x00, 0x00, /* mov $0x17,%eax */
|
|
0xcd, 0x82, /* int $0x82 */
|
|
};
|
|
#define CALLNO_OFFSET 1
|
|
|
|
#endif
|
|
|
|
|
|
static void
|
|
set_hypercall_interface (grub_uint8_t *tgt, unsigned callno)
|
|
{
|
|
if (callno == 0x17)
|
|
{
|
|
grub_memcpy (tgt, template_iret, ARRAY_SIZE (template_iret));
|
|
grub_memset (tgt + ARRAY_SIZE (template_iret), 0xcc,
|
|
HYPERCALL_INTERFACE_SIZE - ARRAY_SIZE (template_iret));
|
|
return;
|
|
}
|
|
grub_memcpy (tgt, template, ARRAY_SIZE (template));
|
|
grub_memset (tgt + ARRAY_SIZE (template), 0xcc,
|
|
HYPERCALL_INTERFACE_SIZE - ARRAY_SIZE (template));
|
|
tgt[CALLNO_OFFSET] = callno & 0xff;
|
|
tgt[CALLNO_OFFSET + 1] = callno >> 8;
|
|
}
|
|
|
|
#ifdef __x86_64__
|
|
#define grub_elfXX_load grub_elf64_load
|
|
#else
|
|
#define grub_elfXX_load grub_elf32_load
|
|
#endif
|
|
|
|
static grub_err_t
|
|
grub_cmd_xen (grub_command_t cmd __attribute__ ((unused)),
|
|
int argc, char *argv[])
|
|
{
|
|
grub_file_t file;
|
|
grub_elf_t elf;
|
|
grub_err_t err;
|
|
void *kern_chunk_src;
|
|
grub_relocator_chunk_t ch;
|
|
grub_addr_t kern_start;
|
|
grub_addr_t kern_end;
|
|
|
|
if (argc == 0)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
|
|
|
|
/* Call grub_loader_unset early to avoid it being called by grub_loader_set */
|
|
grub_loader_unset ();
|
|
|
|
grub_xen_reset ();
|
|
|
|
grub_create_loader_cmdline (argc - 1, argv + 1,
|
|
(char *) xen_state.next_start.cmd_line,
|
|
sizeof (xen_state.next_start.cmd_line) - 1);
|
|
err = grub_verify_string (xen_state.next_start.cmd_line, GRUB_VERIFY_MODULE_CMDLINE);
|
|
if (err)
|
|
return err;
|
|
|
|
file = grub_file_open (argv[0], GRUB_FILE_TYPE_LINUX_KERNEL);
|
|
if (!file)
|
|
return grub_errno;
|
|
|
|
elf = grub_xen_file (file);
|
|
if (!elf)
|
|
goto fail;
|
|
|
|
err = grub_xen_get_info (elf, &xen_state.xen_inf);
|
|
if (err)
|
|
goto fail;
|
|
#ifdef __x86_64__
|
|
if (xen_state.xen_inf.arch != GRUB_XEN_FILE_X86_64)
|
|
#else
|
|
if (xen_state.xen_inf.arch != GRUB_XEN_FILE_I386_PAE
|
|
&& xen_state.xen_inf.arch != GRUB_XEN_FILE_I386_PAE_BIMODE)
|
|
#endif
|
|
{
|
|
grub_error (GRUB_ERR_BAD_OS, "incompatible architecture: %d",
|
|
xen_state.xen_inf.arch);
|
|
goto fail;
|
|
}
|
|
|
|
if (xen_state.xen_inf.virt_base & (PAGE_SIZE - 1))
|
|
{
|
|
grub_error (GRUB_ERR_BAD_OS, "unaligned virt_base");
|
|
goto fail;
|
|
}
|
|
grub_dprintf ("xen", "virt_base = %llx, entry = %llx\n",
|
|
(unsigned long long) xen_state.xen_inf.virt_base,
|
|
(unsigned long long) xen_state.xen_inf.entry_point);
|
|
|
|
xen_state.relocator = grub_relocator_new ();
|
|
if (!xen_state.relocator)
|
|
goto fail;
|
|
|
|
kern_start = xen_state.xen_inf.kern_start - xen_state.xen_inf.paddr_offset;
|
|
kern_end = xen_state.xen_inf.kern_end - xen_state.xen_inf.paddr_offset;
|
|
|
|
if (xen_state.xen_inf.has_hypercall_page)
|
|
{
|
|
grub_dprintf ("xen", "hypercall page at 0x%llx\n",
|
|
(unsigned long long) xen_state.xen_inf.hypercall_page);
|
|
kern_start = grub_min (kern_start, xen_state.xen_inf.hypercall_page -
|
|
xen_state.xen_inf.virt_base);
|
|
kern_end = grub_max (kern_end, xen_state.xen_inf.hypercall_page -
|
|
xen_state.xen_inf.virt_base + PAGE_SIZE);
|
|
}
|
|
|
|
xen_state.max_addr = ALIGN_UP (kern_end, PAGE_SIZE);
|
|
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch, kern_start,
|
|
kern_end - kern_start);
|
|
if (err)
|
|
goto fail;
|
|
kern_chunk_src = get_virtual_current_address (ch);
|
|
|
|
grub_dprintf ("xen", "paddr_offset = 0x%llx\n",
|
|
(unsigned long long) xen_state.xen_inf.paddr_offset);
|
|
grub_dprintf ("xen", "kern_start = 0x%llx, kern_end = 0x%llx\n",
|
|
(unsigned long long) xen_state.xen_inf.kern_start,
|
|
(unsigned long long) xen_state.xen_inf.kern_end);
|
|
|
|
err = grub_elfXX_load (elf, argv[0],
|
|
(grub_uint8_t *) kern_chunk_src - kern_start
|
|
- xen_state.xen_inf.paddr_offset, 0, 0, 0);
|
|
|
|
if (xen_state.xen_inf.has_hypercall_page)
|
|
{
|
|
unsigned i;
|
|
for (i = 0; i < PAGE_SIZE / HYPERCALL_INTERFACE_SIZE; i++)
|
|
set_hypercall_interface ((grub_uint8_t *) kern_chunk_src +
|
|
i * HYPERCALL_INTERFACE_SIZE +
|
|
xen_state.xen_inf.hypercall_page -
|
|
xen_state.xen_inf.virt_base - kern_start, i);
|
|
}
|
|
|
|
if (err)
|
|
goto fail;
|
|
|
|
grub_dl_ref (my_mod);
|
|
xen_state.loaded = 1;
|
|
|
|
grub_loader_set (grub_xen_boot, grub_xen_unload, 0);
|
|
|
|
goto fail;
|
|
|
|
fail:
|
|
/* grub_errno might be clobbered by further calls, save the error reason. */
|
|
err = grub_errno;
|
|
|
|
if (elf)
|
|
grub_elf_close (elf);
|
|
else if (file)
|
|
grub_file_close (file);
|
|
|
|
if (err != GRUB_ERR_NONE)
|
|
grub_xen_reset ();
|
|
|
|
return err;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)),
|
|
int argc, char *argv[])
|
|
{
|
|
grub_size_t size = 0;
|
|
grub_err_t err;
|
|
struct grub_linux_initrd_context initrd_ctx = { 0, 0, 0 };
|
|
grub_relocator_chunk_t ch;
|
|
|
|
if (argc == 0)
|
|
{
|
|
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
|
|
goto fail;
|
|
}
|
|
|
|
if (!xen_state.loaded)
|
|
{
|
|
grub_error (GRUB_ERR_BAD_ARGUMENT,
|
|
N_("you need to load the kernel first"));
|
|
goto fail;
|
|
}
|
|
|
|
if (xen_state.next_start.mod_start || xen_state.next_start.mod_len)
|
|
{
|
|
grub_error (GRUB_ERR_BAD_ARGUMENT, N_("initrd already loaded"));
|
|
goto fail;
|
|
}
|
|
|
|
if (xen_state.xen_inf.unmapped_initrd)
|
|
{
|
|
err = grub_xen_alloc_boot_data ();
|
|
if (err)
|
|
goto fail;
|
|
}
|
|
|
|
if (grub_initrd_init (argc, argv, &initrd_ctx))
|
|
goto fail;
|
|
|
|
size = grub_get_initrd_size (&initrd_ctx);
|
|
|
|
if (size)
|
|
{
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr, size);
|
|
if (err)
|
|
goto fail;
|
|
|
|
if (grub_initrd_load (&initrd_ctx, argv,
|
|
get_virtual_current_address (ch)))
|
|
goto fail;
|
|
}
|
|
|
|
xen_state.next_start.mod_len = size;
|
|
|
|
if (xen_state.xen_inf.unmapped_initrd)
|
|
{
|
|
xen_state.next_start.flags |= SIF_MOD_START_PFN;
|
|
xen_state.next_start.mod_start = xen_state.max_addr >> PAGE_SHIFT;
|
|
}
|
|
else
|
|
xen_state.next_start.mod_start =
|
|
xen_state.max_addr + xen_state.xen_inf.virt_base;
|
|
|
|
grub_dprintf ("xen", "Initrd, addr=0x%x, size=0x%x\n",
|
|
(unsigned) (xen_state.max_addr + xen_state.xen_inf.virt_base),
|
|
(unsigned) size);
|
|
|
|
xen_state.max_addr = ALIGN_UP (xen_state.max_addr + size, PAGE_SIZE);
|
|
|
|
fail:
|
|
grub_initrd_close (&initrd_ctx);
|
|
|
|
return grub_errno;
|
|
}
|
|
|
|
static grub_err_t
|
|
grub_cmd_module (grub_command_t cmd __attribute__ ((unused)),
|
|
int argc, char *argv[])
|
|
{
|
|
grub_size_t size = 0;
|
|
grub_err_t err;
|
|
grub_relocator_chunk_t ch;
|
|
grub_size_t cmdline_len;
|
|
int nounzip = 0;
|
|
grub_file_t file;
|
|
|
|
if (argc == 0)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
|
|
|
|
if (grub_strcmp (argv[0], "--nounzip") == 0)
|
|
{
|
|
argv++;
|
|
argc--;
|
|
nounzip = 1;
|
|
}
|
|
|
|
if (argc == 0)
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
|
|
|
|
if (!xen_state.loaded)
|
|
{
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT,
|
|
N_("you need to load the kernel first"));
|
|
}
|
|
|
|
if ((xen_state.next_start.mod_start || xen_state.next_start.mod_len) &&
|
|
!xen_state.module_info_page)
|
|
{
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("initrd already loaded"));
|
|
}
|
|
|
|
/* Leave one space for terminator. */
|
|
if (xen_state.n_modules >= MAX_MODULES - 1)
|
|
{
|
|
return grub_error (GRUB_ERR_BAD_ARGUMENT, "too many modules");
|
|
}
|
|
|
|
if (!xen_state.module_info_page)
|
|
{
|
|
xen_state.xen_inf.unmapped_initrd = 0;
|
|
xen_state.n_modules = 0;
|
|
xen_state.max_addr = ALIGN_UP (xen_state.max_addr, PAGE_SIZE);
|
|
xen_state.modules_target_start = xen_state.max_addr;
|
|
xen_state.next_start.mod_start =
|
|
xen_state.max_addr + xen_state.xen_inf.virt_base;
|
|
xen_state.next_start.flags |= SIF_MULTIBOOT_MOD;
|
|
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr, MAX_MODULES
|
|
*
|
|
sizeof (xen_state.module_info_page
|
|
[0]));
|
|
if (err)
|
|
return err;
|
|
xen_state.module_info_page = get_virtual_current_address (ch);
|
|
grub_memset (xen_state.module_info_page, 0, MAX_MODULES
|
|
* sizeof (xen_state.module_info_page[0]));
|
|
xen_state.max_addr +=
|
|
MAX_MODULES * sizeof (xen_state.module_info_page[0]);
|
|
}
|
|
|
|
xen_state.max_addr = ALIGN_UP (xen_state.max_addr, PAGE_SIZE);
|
|
|
|
file = grub_file_open (argv[0], GRUB_FILE_TYPE_LINUX_INITRD |
|
|
(nounzip ? GRUB_FILE_TYPE_NO_DECOMPRESS : GRUB_FILE_TYPE_NONE));
|
|
if (!file)
|
|
return grub_errno;
|
|
size = grub_file_size (file);
|
|
|
|
cmdline_len = grub_loader_cmdline_size (argc - 1, argv + 1);
|
|
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr, cmdline_len);
|
|
if (err)
|
|
goto fail;
|
|
|
|
grub_create_loader_cmdline (argc - 1, argv + 1,
|
|
get_virtual_current_address (ch), cmdline_len);
|
|
err = grub_verify_string (get_virtual_current_address (ch), GRUB_VERIFY_MODULE_CMDLINE);
|
|
if (err)
|
|
goto fail;
|
|
|
|
xen_state.module_info_page[xen_state.n_modules].cmdline =
|
|
xen_state.max_addr - xen_state.modules_target_start;
|
|
xen_state.max_addr = ALIGN_UP (xen_state.max_addr + cmdline_len, PAGE_SIZE);
|
|
|
|
if (size)
|
|
{
|
|
err = grub_relocator_alloc_chunk_addr (xen_state.relocator, &ch,
|
|
xen_state.max_addr, size);
|
|
if (err)
|
|
goto fail;
|
|
if (grub_file_read (file, get_virtual_current_address (ch), size)
|
|
!= (grub_ssize_t) size)
|
|
{
|
|
if (!grub_errno)
|
|
grub_error (GRUB_ERR_FILE_READ_ERROR,
|
|
N_("premature end of file %s"), argv[0]);
|
|
goto fail;
|
|
}
|
|
}
|
|
xen_state.next_start.mod_len =
|
|
xen_state.max_addr + size - xen_state.modules_target_start;
|
|
xen_state.module_info_page[xen_state.n_modules].mod_start =
|
|
xen_state.max_addr - xen_state.modules_target_start;
|
|
xen_state.module_info_page[xen_state.n_modules].mod_end =
|
|
xen_state.max_addr + size - xen_state.modules_target_start;
|
|
|
|
xen_state.n_modules++;
|
|
grub_dprintf ("xen", "module, addr=0x%x, size=0x%x\n",
|
|
(unsigned) xen_state.max_addr, (unsigned) size);
|
|
xen_state.max_addr = ALIGN_UP (xen_state.max_addr + size, PAGE_SIZE);
|
|
|
|
|
|
fail:
|
|
grub_file_close (file);
|
|
|
|
return grub_errno;
|
|
}
|
|
|
|
static grub_command_t cmd_xen, cmd_initrd, cmd_module, cmd_multiboot;
|
|
|
|
GRUB_MOD_INIT (xen)
|
|
{
|
|
cmd_xen = grub_register_command ("linux", grub_cmd_xen,
|
|
0, N_("Load Linux."));
|
|
cmd_multiboot = grub_register_command ("multiboot", grub_cmd_xen,
|
|
0, N_("Load Linux."));
|
|
cmd_initrd = grub_register_command ("initrd", grub_cmd_initrd,
|
|
0, N_("Load initrd."));
|
|
cmd_module = grub_register_command ("module", grub_cmd_module,
|
|
0, N_("Load module."));
|
|
my_mod = mod;
|
|
}
|
|
|
|
GRUB_MOD_FINI (xen)
|
|
{
|
|
grub_unregister_command (cmd_xen);
|
|
grub_unregister_command (cmd_initrd);
|
|
grub_unregister_command (cmd_multiboot);
|
|
grub_unregister_command (cmd_module);
|
|
}
|