自学教程：C++ DOMPRINTF函数代码示例

static int vcpu_arm64(struct xc_dom_image *dom, void *ptr){    vcpu_guest_context_t *ctxt = ptr;    DOMPRINTF_CALLED(dom->xch);    /* clear everything */    memset(ctxt, 0, sizeof(*ctxt));    ctxt->user_regs.pc64 = dom->parms.virt_entry;    /* Linux boot protocol. See linux.Documentation/arm64/booting.txt. */    ctxt->user_regs.x0 = dom->devicetree_blob ?        dom->devicetree_seg.vstart : 0xffffffff;    ctxt->user_regs.x1 = 0;    ctxt->user_regs.x2 = 0;    ctxt->user_regs.x3 = 0;    DOMPRINTF("DTB %"PRIx64, ctxt->user_regs.x0);    ctxt->sctlr = SCTLR_GUEST_INIT;    ctxt->ttbr0 = 0;    ctxt->ttbr1 = 0;    ctxt->ttbcr = 0; /* Defined Reset Value */    ctxt->user_regs.cpsr = PSR_GUEST64_INIT;    ctxt->flags = VGCF_online;    DOMPRINTF("Initial state CPSR %#"PRIx32" PC %#"PRIx64,           ctxt->user_regs.cpsr, ctxt->user_regs.pc64);    return 0;}

void *xc_dom_malloc_page_aligned(struct xc_dom_image *dom, size_t size){    struct xc_dom_mem *block;    block = malloc(sizeof(*block));    if ( block == NULL )    {        DOMPRINTF("%s: allocation failed", __FUNCTION__);        return NULL;    }    memset(block, 0, sizeof(*block));    block->mmap_len = size;    block->mmap_ptr = mmap(NULL, block->mmap_len,                           PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON,                           -1, 0);    if ( block->mmap_ptr == MAP_FAILED )    {        DOMPRINTF("%s: mmap failed", __FUNCTION__);        free(block);        return NULL;    }    block->next = dom->memblocks;    dom->memblocks = block;    dom->alloc_malloc += sizeof(*block);    dom->alloc_mem_map += block->mmap_len;    if ( size > (100 * 1024) )        print_mem(dom, __FUNCTION__, size);    return block->mmap_ptr;}

static void print_mem(struct xc_dom_image *dom, const char *name, size_t mem){    if ( mem > (32 * 1024 * 1024) )        DOMPRINTF("%-24s : %zd MB", name, mem / (1024 * 1024));    else if ( mem > (32 * 1024) )        DOMPRINTF("%-24s : %zd kB", name, mem / 1024);    else        DOMPRINTF("%-24s : %zd bytes", name, mem);}

void xc_dom_log_memory_footprint(struct xc_dom_image *dom){    DOMPRINTF("domain builder memory footprint");    DOMPRINTF("   allocated");    print_mem(dom, "      malloc", dom->alloc_malloc);    print_mem(dom, "      anon mmap", dom->alloc_mem_map);    DOMPRINTF("   mapped");    print_mem(dom, "      file mmap", dom->alloc_file_map);    print_mem(dom, "      domU mmap", dom->alloc_domU_map);}

int xc_dom_alloc_segment(struct xc_dom_image *dom,                         struct xc_dom_seg *seg, char *name,                         xen_vaddr_t start, xen_vaddr_t size){    unsigned int page_size = XC_DOM_PAGE_SIZE(dom);    xen_pfn_t pages;    void *ptr;    if ( start && xc_dom_alloc_pad(dom, start) )        return -1;    pages = (size + page_size - 1) / page_size;    start = dom->virt_alloc_end;    seg->pfn = dom->pfn_alloc_end;    seg->pages = pages;    if ( xc_dom_chk_alloc_pages(dom, name, pages) )        return -1;    /* map and clear pages */    ptr = xc_dom_seg_to_ptr(dom, seg);    if ( ptr == NULL )        return -1;    memset(ptr, 0, pages * page_size);    seg->vstart = start;    seg->vend = dom->virt_alloc_end;    DOMPRINTF("%-20s:   %-12s : 0x%" PRIx64 " -> 0x%" PRIx64              "  (pfn 0x%" PRIpfn " + 0x%" PRIpfn " pages)",              __FUNCTION__, name, seg->vstart, seg->vend, seg->pfn, pages);    return 0;}

static int xc_try_lzo1x_decode(    struct xc_dom_image *dom, void **blob, size_t *size){    DOMPRINTF("%s: LZO1x decompress support unavailable/n",                  __FUNCTION__);    return -1;}

static int xc_try_bzip2_decode(    struct xc_dom_image *dom, void **blob, size_t *size){    DOMPRINTF("%s: BZIP2 decompress support unavailable",              __FUNCTION__);    return -1;}

int xc_dom_compat_check(struct xc_dom_image *dom){    xen_capabilities_info_t xen_caps;    char *item, *ptr;    int match, found = 0;    strncpy(xen_caps, dom->xen_caps, XEN_CAPABILITIES_INFO_LEN - 1);    xen_caps[XEN_CAPABILITIES_INFO_LEN - 1] = '/0';    for ( item = strtok_r(xen_caps, " ", &ptr);          item != NULL ; item = strtok_r(NULL, " ", &ptr) )    {        match = !strcmp(dom->guest_type, item);        DOMPRINTF("%s: supported guest type: %s%s", __FUNCTION__,                  item, match ? " <= matches" : "");        if ( match )            found++;    }    if ( !found )        xc_dom_panic(dom->xch, XC_INVALID_KERNEL,                     "%s: guest type %s not supported by xen kernel, sorry",                     __FUNCTION__, dom->guest_type);    return found;}

void xc_dom_unmap_one(struct xc_dom_image *dom, xen_pfn_t pfn){    unsigned int page_shift = XC_DOM_PAGE_SHIFT(dom);    struct xc_dom_phys *phys, *prev = NULL;    for ( phys = dom->phys_pages; phys != NULL; phys = phys->next )    {        if ( (pfn >= phys->first) && (pfn < (phys->first + phys->count)) )            break;        prev = phys;    }    if ( !phys )    {        DOMPRINTF("%s: Huh? no mapping with pfn 0x%" PRIpfn "",                  __FUNCTION__, pfn);        return;    }    munmap(phys->ptr, phys->count << page_shift);    if ( prev )        prev->next = phys->next;    else        dom->phys_pages = phys->next;    xc_domain_cacheflush(dom->xch, dom->guest_domid, phys->first, phys->count);}

static int xc_dom_parse_zimage32_kernel(struct xc_dom_image *dom){    uint32_t *zimage;    uint32_t start, entry_addr;    uint64_t v_start, v_end;    uint64_t rambase = dom->rambase_pfn << XC_PAGE_SHIFT;    DOMPRINTF_CALLED(dom->xch);    zimage = (uint32_t *)dom->kernel_blob;    /* Do not load kernel at the very first RAM address */    v_start = rambase + 0x8000;    if ( dom->kernel_size > UINT64_MAX - v_start )    {        DOMPRINTF("%s: kernel is too large/n", __FUNCTION__);        return -EINVAL;    }    v_end = v_start + dom->kernel_size;    /*     * If start is invalid then the guest will start at some invalid     * address and crash, but this happens in guest context so doesn't     * concern us here.     */    start = zimage[ZIMAGE32_START_OFFSET/4];    if (start == 0)        entry_addr = v_start;    else        entry_addr = start;    /* find kernel segment */    dom->kernel_seg.vstart = v_start;    dom->kernel_seg.vend   = v_end;    dom->parms.virt_entry = entry_addr;    dom->parms.virt_base = rambase;    dom->guest_type = "xen-3.0-armv7l";    DOMPRINTF("%s: %s: 0x%" PRIx64 " -> 0x%" PRIx64 "",              __FUNCTION__, dom->guest_type,              dom->kernel_seg.vstart, dom->kernel_seg.vend);    return 0;}

int xc_dom_alloc_segment(struct xc_dom_image *dom,                         struct xc_dom_seg *seg, char *name,                         xen_vaddr_t start, xen_vaddr_t size){    unsigned int page_size = XC_DOM_PAGE_SIZE(dom);    xen_pfn_t pages = (size + page_size - 1) / page_size;    xen_pfn_t pfn;    void *ptr;    if ( start == 0 )        start = dom->virt_alloc_end;    if ( start & (page_size - 1) )    {        xc_dom_panic(dom->xch, XC_INTERNAL_ERROR,                     "%s: segment start isn't page aligned (0x%" PRIx64 ")",                     __FUNCTION__, start);        return -1;    }    if ( start < dom->virt_alloc_end )    {        xc_dom_panic(dom->xch, XC_INTERNAL_ERROR,                     "%s: segment start too low (0x%" PRIx64 " < 0x%" PRIx64                     ")", __FUNCTION__, start, dom->virt_alloc_end);        return -1;    }    seg->vstart = start;    pfn = (seg->vstart - dom->parms.virt_base) / page_size;    seg->pfn = pfn + dom->rambase_pfn;    if ( pages > dom->total_pages || /* multiple test avoids overflow probs */         pfn > dom->total_pages ||         pages > dom->total_pages - pfn)    {        xc_dom_panic(dom->xch, XC_OUT_OF_MEMORY,                     "%s: segment %s too large (0x%"PRIpfn" > "                     "0x%"PRIpfn" - 0x%"PRIpfn" pages)",                     __FUNCTION__, name, pages, dom->total_pages, pfn);        return -1;    }    seg->vend = start + pages * page_size;    dom->virt_alloc_end = seg->vend;    if (dom->allocate)        dom->allocate(dom, dom->virt_alloc_end);    DOMPRINTF("%-20s:   %-12s : 0x%" PRIx64 " -> 0x%" PRIx64              "  (pfn 0x%" PRIpfn " + 0x%" PRIpfn " pages)",              __FUNCTION__, name, seg->vstart, seg->vend, seg->pfn, pages);    /* map and clear pages */    ptr = xc_dom_seg_to_ptr(dom, seg);    if ( ptr == NULL )        return -1;    memset(ptr, 0, pages * page_size);    return 0;}

int xc_dom_kernel_file(struct xc_dom_image *dom, const char *filename){    DOMPRINTF("%s: filename=/"%s/"", __FUNCTION__, filename);    dom->kernel_blob = xc_dom_malloc_filemap(dom, filename, &dom->kernel_size,                                             dom->max_kernel_size);    if ( dom->kernel_blob == NULL )        return -1;    return xc_dom_try_gunzip(dom, &dom->kernel_blob, &dom->kernel_size);}

static int xc_dom_load_bin_kernel(struct xc_dom_image *dom){    struct xen_bin_image_table *image_info;    char *image = dom->kernel_blob;    char *dest;    size_t image_size = dom->kernel_size;    size_t dest_size;    uint32_t start_addr;    uint32_t load_end_addr;    uint32_t bss_end_addr;    uint32_t skip, text_size, bss_size;    image_info = find_table(dom);    if ( !image_info )        return -EINVAL;    start_addr = image_info->header_addr - ((char *)image_info - image);    load_end_addr = image_info->load_end_addr ?: start_addr + image_size;    bss_end_addr = image_info->bss_end_addr ?: load_end_addr;    /* It's possible that we need to skip the first part of the image */    skip = image_info->load_addr - start_addr;    text_size = load_end_addr - image_info->load_addr;    bss_size = bss_end_addr - load_end_addr;    DOMPRINTF("%s: calculated sizes", __FUNCTION__);    DOMPRINTF("  skip:      0x%" PRIx32 "", skip);    DOMPRINTF("  text_size: 0x%" PRIx32 "", text_size);    DOMPRINTF("  bss_size:  0x%" PRIx32 "", bss_size);    dest = xc_dom_vaddr_to_ptr(dom, dom->kernel_seg.vstart, &dest_size);    if ( dest == NULL )    {        DOMPRINTF("%s: xc_dom_vaddr_to_ptr(dom, dom->kernel_seg.vstart)"                  " => NULL", __FUNCTION__);        return -EINVAL;    }    if ( dest_size < text_size ||         dest_size - text_size < bss_size )    {        DOMPRINTF("%s: mapped region is too small for image", __FUNCTION__);        return -EINVAL;    }    if ( image_size < skip ||         image_size - skip < text_size )    {        DOMPRINTF("%s: image is too small for declared text size",                  __FUNCTION__);        return -EINVAL;    }    memcpy(dest, image + skip, text_size);    memset(dest + text_size, 0, bss_size);    return 0;}

static struct xc_dom_loader *xc_dom_find_loader(struct xc_dom_image *dom){    struct xc_dom_loader *loader = first_loader;    while ( loader != NULL )    {        DOMPRINTF("%s: trying %s loader ... ", __FUNCTION__, loader->name);        if ( loader->probe(dom) == 0 )        {            DOMPRINTF("loader probe OK");            return loader;        }        DOMPRINTF("loader probe failed");        loader = loader->next;    }    xc_dom_panic(dom->xch,                 XC_INVALID_KERNEL, "%s: no loader found", __FUNCTION__);    return NULL;}

static elf_errorstatus xc_dom_load_elf_symtab(struct xc_dom_image *dom,                                  struct elf_binary *elf, bool load){    struct elf_binary syms;    ELF_HANDLE_DECL(elf_shdr) shdr; ELF_HANDLE_DECL(elf_shdr) shdr2;    xen_vaddr_t symtab, maxaddr;    elf_ptrval hdr;    size_t size;    unsigned h, count, type, i, tables = 0;    unsigned long *strtab_referenced = NULL;    if ( elf_swap(elf) )    {        DOMPRINTF("%s: non-native byte order, bsd symtab not supported",                  __FUNCTION__);        return 0;    }    size = elf->bsd_symtab_pend - elf->bsd_symtab_pstart;    if ( load )    {        char *hdr_ptr;        size_t allow_size;        if ( !dom->bsd_symtab_start )            return 0;        hdr_ptr = xc_dom_vaddr_to_ptr(dom, dom->bsd_symtab_start, &allow_size);        if ( hdr_ptr == NULL )        {            DOMPRINTF("%s: xc_dom_vaddr_to_ptr(dom,dom->bsd_symtab_start"                      " => NULL", __FUNCTION__);            return -1;        }        elf->caller_xdest_base = hdr_ptr;        elf->caller_xdest_size = allow_size;        hdr = ELF_REALPTR2PTRVAL(hdr_ptr);        elf_store_val(elf, unsigned, hdr, size - sizeof(unsigned));    }    else    {

static int xc_dom_parse_elf_kernel(struct xc_dom_image *dom){    struct elf_binary *elf;    int rc;    rc = check_elf_kernel(dom, 1);    if ( rc != 0 )        return rc;    elf = xc_dom_malloc(dom, sizeof(*elf));    dom->private_loader = elf;    rc = elf_init(elf, dom->kernel_blob, dom->kernel_size);    xc_elf_set_logfile(dom->xch, elf, 1);    if ( rc != 0 )    {        xc_dom_panic(dom->xch, XC_INVALID_KERNEL, "%s: corrupted ELF image",                     __FUNCTION__);        return rc;    }    /* Find the section-header strings table. */    if ( elf->sec_strtab == NULL )    {        xc_dom_panic(dom->xch, XC_INVALID_KERNEL, "%s: ELF image"                     " has no shstrtab", __FUNCTION__);        return -EINVAL;    }    /* parse binary and get xen meta info */    elf_parse_binary(elf);    if ( (rc = elf_xen_parse(elf, &dom->parms)) != 0 )        return rc;    if ( elf_xen_feature_get(XENFEAT_dom0, dom->parms.f_required) )    {        xc_dom_panic(dom->xch, XC_INVALID_KERNEL, "%s: Kernel does not"                     " support unprivileged (DomU) operation", __FUNCTION__);        return -EINVAL;    }    /* find kernel segment */    dom->kernel_seg.vstart = dom->parms.virt_kstart;    dom->kernel_seg.vend   = dom->parms.virt_kend;    if ( dom->parms.bsd_symtab )        xc_dom_load_elf_symtab(dom, elf, 0);    dom->guest_type = xc_dom_guest_type(dom, elf);    DOMPRINTF("%s: %s: 0x%" PRIx64 " -> 0x%" PRIx64 "",              __FUNCTION__, dom->guest_type,              dom->kernel_seg.vstart, dom->kernel_seg.vend);    return 0;}

static int xc_dom_parse_zimage64_kernel(struct xc_dom_image *dom){    struct zimage64_hdr *zimage;    uint64_t v_start, v_end;    uint64_t rambase = dom->rambase_pfn << XC_PAGE_SHIFT;    DOMPRINTF_CALLED(dom->xch);    zimage = dom->kernel_blob;    if ( zimage->text_offset > UINT64_MAX - rambase )    {        DOMPRINTF("%s: kernel text offset is too large/n", __FUNCTION__);        return -EINVAL;    }    v_start = rambase + zimage->text_offset;    if ( dom->kernel_size > UINT64_MAX - v_start )    {        DOMPRINTF("%s: kernel is too large/n", __FUNCTION__);        return -EINVAL;    }    v_end = v_start + dom->kernel_size;    dom->kernel_seg.vstart = v_start;    dom->kernel_seg.vend   = v_end;    /* Call the kernel at offset 0 */    dom->parms.virt_entry = v_start;    dom->parms.virt_base = rambase;    dom->guest_type = "xen-3.0-aarch64";    DOMPRINTF("%s: %s: 0x%" PRIx64 " -> 0x%" PRIx64 "",              __FUNCTION__, dom->guest_type,              dom->kernel_seg.vstart, dom->kernel_seg.vend);    return 0;}

static int xc_dom_parse_zimage_kernel(struct xc_dom_image *dom){    uint32_t *zimage;    uint32_t start, entry_addr;    uint64_t v_start, v_end;    uint64_t rambase = GUEST_RAM_BASE;    DOMPRINTF_CALLED(dom->xch);    zimage = (uint32_t *)dom->kernel_blob;    dom->rambase_pfn = rambase >> XC_PAGE_SHIFT;    /* Do not load kernel at the very first RAM address */    v_start = rambase + 0x8000;    v_end = v_start + dom->kernel_size;    start = zimage[ZIMAGE_START_OFFSET/4];    if (start == 0)        entry_addr = v_start;    else        entry_addr = start;    /* find kernel segment */    dom->kernel_seg.vstart = v_start;    dom->kernel_seg.vend   = v_end;    dom->parms.virt_entry = entry_addr;    dom->parms.virt_base = rambase;    dom->guest_type = "xen-3.0-armv7l";    DOMPRINTF("%s: %s: RAM starts at %"PRI_xen_pfn,              __FUNCTION__, dom->guest_type, dom->rambase_pfn);    DOMPRINTF("%s: %s: 0x%" PRIx64 " -> 0x%" PRIx64 "",              __FUNCTION__, dom->guest_type,              dom->kernel_seg.vstart, dom->kernel_seg.vend);    return 0;}

static int xc_try_lzma_decode(    struct xc_dom_image *dom, void **blob, size_t *size){    lzma_stream stream = LZMA_STREAM_INIT;    if ( lzma_alone_decoder(&stream, LZMA_BLOCK_SIZE) != LZMA_OK )    {        DOMPRINTF("LZMA: Failed to init decoder");        return -1;    }    return _xc_try_lzma_decode(dom, blob, size, &stream, "LZMA");}

static int xc_dom_load_zimage_kernel(struct xc_dom_image *dom){    void *dst;    DOMPRINTF_CALLED(dom->xch);    dst = xc_dom_seg_to_ptr(dom, &dom->kernel_seg);    if ( dst == NULL )    {        DOMPRINTF("%s: xc_dom_seg_to_ptr(dom, &dom->kernel_seg) => NULL",                  __func__);        return -1;    }    DOMPRINTF("%s: kernel sed %#"PRIx64"-%#"PRIx64,              __func__, dom->kernel_seg.vstart, dom->kernel_seg.vend);    DOMPRINTF("%s: copy %zd bytes from blob %p to dst %p",              __func__, dom->kernel_size, dom->kernel_blob, dst);    memcpy(dst, dom->kernel_blob, dom->kernel_size);    return 0;}

void *xc_dom_malloc(struct xc_dom_image *dom, size_t size){    struct xc_dom_mem *block;    if ( size > SIZE_MAX - sizeof(*block) )    {        DOMPRINTF("%s: unreasonable allocation size", __FUNCTION__);        return NULL;    }    block = malloc(sizeof(*block) + size);    if ( block == NULL )    {        DOMPRINTF("%s: allocation failed", __FUNCTION__);        return NULL;    }    memset(block, 0, sizeof(*block) + size);    block->next = dom->memblocks;    dom->memblocks = block;    dom->alloc_malloc += sizeof(*block) + size;    if ( size > (100 * 1024) )        print_mem(dom, __FUNCTION__, size);    return block->memory;}

xen_pfn_t xc_dom_alloc_page(struct xc_dom_image *dom, char *name){    xen_vaddr_t start;    xen_pfn_t pfn;    start = dom->virt_alloc_end;    pfn = dom->pfn_alloc_end - dom->rambase_pfn;    if ( xc_dom_chk_alloc_pages(dom, name, 1) )        return INVALID_PFN;    DOMPRINTF("%-20s:   %-12s : 0x%" PRIx64 " (pfn 0x%" PRIpfn ")",              __FUNCTION__, name, start, pfn);    return pfn;}

int xc_dom_devicetree_file(struct xc_dom_image *dom, const char *filename){#if defined (__arm__) || defined(__aarch64__)    DOMPRINTF("%s: filename=/"%s/"", __FUNCTION__, filename);    dom->devicetree_blob =        xc_dom_malloc_filemap(dom, filename, &dom->devicetree_size,                              dom->max_devicetree_size);    if ( dom->devicetree_blob == NULL )        return -1;    return 0;#else    errno = -EINVAL;    return -1;#endif}

int xc_dom_alloc_page(struct xc_dom_image *dom, char *name){    unsigned int page_size = XC_DOM_PAGE_SIZE(dom);    xen_vaddr_t start;    xen_pfn_t pfn;    start = dom->virt_alloc_end;    dom->virt_alloc_end += page_size;    if (dom->allocate)        dom->allocate(dom, dom->virt_alloc_end);    pfn = (start - dom->parms.virt_base) / page_size;    DOMPRINTF("%-20s:   %-12s : 0x%" PRIx64 " (pfn 0x%" PRIpfn ")",              __FUNCTION__, name, start, pfn);    return pfn;}

static int clear_page(struct xc_dom_image *dom, xen_pfn_t pfn){    xen_pfn_t dst;    int rc;    if ( pfn == 0 )        return 0;    dst = xc_dom_p2m_host(dom, pfn);    DOMPRINTF("%s: pfn 0x%" PRIpfn ", mfn 0x%" PRIpfn "",              __FUNCTION__, pfn, dst);    rc = xc_clear_domain_page(dom->xch, dom->guest_domid, dst);    if ( rc != 0 )        xc_dom_panic(dom->xch, XC_INTERNAL_ERROR,                     "%s: xc_clear_domain_page failed (pfn 0x%" PRIpfn                     ", rc=%d)", __FUNCTION__, pfn, rc);    return rc;}

int xc_dom_register_external(struct xc_dom_image *dom, void *ptr, size_t size){    struct xc_dom_mem *block;    block = malloc(sizeof(*block));    if ( block == NULL )    {        DOMPRINTF("%s: allocation failed", __FUNCTION__);        return -1;    }    memset(block, 0, sizeof(*block));    block->ptr = ptr;    block->len = size;    block->type = XC_DOM_MEM_TYPE_MALLOC_EXTERNAL;    block->next = dom->memblocks;    dom->memblocks = block;    dom->alloc_malloc += sizeof(*block);    dom->alloc_mem_map += block->len;    return 0;}

static int setup_hypercall_page(struct xc_dom_image *dom){    DECLARE_DOMCTL;    xen_pfn_t pfn;    int rc;    if ( dom->parms.virt_hypercall == -1 )        return 0;    pfn = (dom->parms.virt_hypercall - dom->parms.virt_base)        >> XC_DOM_PAGE_SHIFT(dom);    DOMPRINTF("%s: vaddr=0x%" PRIx64 " pfn=0x%" PRIpfn "", __FUNCTION__,                  dom->parms.virt_hypercall, pfn);    domctl.cmd = XEN_DOMCTL_hypercall_init;    domctl.domain = dom->guest_domid;    domctl.u.hypercall_init.gmfn = xc_dom_p2m_guest(dom, pfn);    rc = do_domctl(dom->xch, &domctl);    if ( rc != 0 )        xc_dom_panic(dom->xch, XC_INTERNAL_ERROR,                     "%s: HYPERCALL_INIT failed: %d - %s)",                     __FUNCTION__, errno, strerror(errno));    return rc;}

static int vcpu_arm32(struct xc_dom_image *dom, void *ptr){    vcpu_guest_context_t *ctxt = ptr;    DOMPRINTF_CALLED(dom->xch);    /* clear everything */    memset(ctxt, 0, sizeof(*ctxt));    ctxt->user_regs.pc32 = dom->parms.virt_entry;    /* Linux boot protocol. See linux.Documentation/arm/Booting. */    ctxt->user_regs.r0_usr = 0; /* SBZ */    /* Machine ID: We use DTB therefore no machine id */    ctxt->user_regs.r1_usr = 0xffffffff;    /* ATAGS/DTB: We currently require that the guest kernel to be     * using CONFIG_ARM_APPENDED_DTB. Ensure that r2 does not look     * like a valid pointer to a set of ATAGS or a DTB.     */    ctxt->user_regs.r2_usr = dom->devicetree_blob ?        dom->devicetree_seg.vstart : 0xffffffff;    ctxt->sctlr = SCTLR_GUEST_INIT;    ctxt->ttbr0 = 0;    ctxt->ttbr1 = 0;    ctxt->ttbcr = 0; /* Defined Reset Value */    ctxt->user_regs.cpsr = PSR_GUEST32_INIT;    ctxt->flags = VGCF_online;    DOMPRINTF("Initial state CPSR %#"PRIx32" PC %#"PRIx32,           ctxt->user_regs.cpsr, ctxt->user_regs.pc32);    return 0;}

int xc_dom_devicetree_max_size(struct xc_dom_image *dom, size_t sz){    DOMPRINTF("%s: devicetree_max_size=%zx", __FUNCTION__, sz);    dom->max_devicetree_size = sz;    return 0;}

int xc_dom_ramdisk_max_size(struct xc_dom_image *dom, size_t sz){    DOMPRINTF("%s: ramdisk_max_size=%zx", __FUNCTION__, sz);    dom->max_ramdisk_size = sz;    return 0;}