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

static void xen_load_sp0(struct tss_struct *tss,			 struct thread_struct *thread){	struct multicall_space mcs = xen_mc_entry(0);	MULTI_stack_switch(mcs.mc, __KERNEL_DS, thread->sp0);	xen_mc_issue(PARAVIRT_LAZY_CPU);}

static void xen_clts(void){	struct multicall_space mcs;	mcs = xen_mc_entry(0);	MULTI_fpu_taskswitch(mcs.mc, 0);	xen_mc_issue(PARAVIRT_LAZY_CPU);}

static void xen_write_cr0(unsigned long cr0){	struct multicall_space mcs;	this_cpu_write(xen_cr0_value, cr0);	mcs = xen_mc_entry(0);	MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);	xen_mc_issue(PARAVIRT_LAZY_CPU);}

static void xen_write_cr0(unsigned long cr0){	struct multicall_space mcs;	/* Only pay attention to cr0.TS; everything else is	   ignored. */	mcs = xen_mc_entry(0);	MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);	xen_mc_issue(PARAVIRT_LAZY_CPU);}

/* Add an MFN override for a particular page */static int m2p_add_override(unsigned long mfn, struct page *page,			    struct gnttab_map_grant_ref *kmap_op){	unsigned long flags;	unsigned long pfn;	unsigned long uninitialized_var(address);	unsigned level;	pte_t *ptep = NULL;	pfn = page_to_pfn(page);	if (!PageHighMem(page)) {		address = (unsigned long)__va(pfn << PAGE_SHIFT);		ptep = lookup_address(address, &level);		if (WARN(ptep == NULL || level != PG_LEVEL_4K,			 "m2p_add_override: pfn %lx not mapped", pfn))			return -EINVAL;	}	if (kmap_op != NULL) {		if (!PageHighMem(page)) {			struct multicall_space mcs =				xen_mc_entry(sizeof(*kmap_op));			MULTI_grant_table_op(mcs.mc,					GNTTABOP_map_grant_ref, kmap_op, 1);			xen_mc_issue(PARAVIRT_LAZY_MMU);		}	}	spin_lock_irqsave(&m2p_override_lock, flags);	list_add(&page->lru,  &m2p_overrides[mfn_hash(mfn)]);	spin_unlock_irqrestore(&m2p_override_lock, flags);	/* p2m(m2p(mfn)) == mfn: the mfn is already present somewhere in	 * this domain. Set the FOREIGN_FRAME_BIT in the p2m for the other	 * pfn so that the following mfn_to_pfn(mfn) calls will return the	 * pfn from the m2p_override (the backend pfn) instead.	 * We need to do this because the pages shared by the frontend	 * (xen-blkfront) can be already locked (lock_page, called by	 * do_read_cache_page); when the userspace backend tries to use them	 * with direct_IO, mfn_to_pfn returns the pfn of the frontend, so	 * do_blockdev_direct_IO is going to try to lock the same pages	 * again resulting in a deadlock.	 * As a side effect get_user_pages_fast might not be safe on the	 * frontend pages while they are being shared with the backend,	 * because mfn_to_pfn (that ends up being called by GUPF) will	 * return the backend pfn rather than the frontend pfn. */	pfn = mfn_to_pfn_no_overrides(mfn);	if (__pfn_to_mfn(pfn) == mfn)		set_phys_to_machine(pfn, FOREIGN_FRAME(mfn));	return 0;}

static void xen_set_ldt(const void *addr, unsigned entries){	struct mmuext_op *op;	struct multicall_space mcs = xen_mc_entry(sizeof(*op));	op = mcs.args;	op->cmd = MMUEXT_SET_LDT;	op->arg1.linear_addr = (unsigned long)addr;	op->arg2.nr_ents = entries;	MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);	xen_mc_issue(PARAVIRT_LAZY_CPU);}

void xen_set_pmd(pmd_t *ptr, pmd_t val){	struct multicall_space mcs;	struct mmu_update *u;	preempt_disable();	mcs = xen_mc_entry(sizeof(*u));	u = mcs.args;	u->ptr = virt_to_machine(ptr).maddr;	u->val = pmd_val_ma(val);	MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);	xen_mc_issue(PARAVIRT_LAZY_MMU);	preempt_enable();}

void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,		    pte_t *ptep, pte_t pteval){	if (mm == current->mm || mm == &init_mm) {		if (xen_get_lazy_mode() == PARAVIRT_LAZY_MMU) {			struct multicall_space mcs;			mcs = xen_mc_entry(0);			MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);			xen_mc_issue(PARAVIRT_LAZY_MMU);			return;		} else			if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)				return;	}	xen_set_pte(ptep, pteval);}

int m2p_remove_override(struct page *page, bool clear_pte){	unsigned long flags;	unsigned long mfn;	unsigned long pfn;	unsigned long uninitialized_var(address);	unsigned level;	pte_t *ptep = NULL;	int ret = 0;	pfn = page_to_pfn(page);	mfn = get_phys_to_machine(pfn);	if (mfn == INVALID_P2M_ENTRY || !(mfn & FOREIGN_FRAME_BIT))		return -EINVAL;	if (!PageHighMem(page)) {		address = (unsigned long)__va(pfn << PAGE_SHIFT);		ptep = lookup_address(address, &level);		if (WARN(ptep == NULL || level != PG_LEVEL_4K,					"m2p_remove_override: pfn %lx not mapped", pfn))			return -EINVAL;	}	spin_lock_irqsave(&m2p_override_lock, flags);	list_del(&page->lru);	spin_unlock_irqrestore(&m2p_override_lock, flags);	WARN_ON(!PagePrivate(page));	ClearPagePrivate(page);	if (clear_pte) {		struct gnttab_map_grant_ref *map_op =			(struct gnttab_map_grant_ref *) page->index;		set_phys_to_machine(pfn, map_op->dev_bus_addr);		if (!PageHighMem(page)) {			struct multicall_space mcs;			struct gnttab_unmap_grant_ref *unmap_op;			/*			 * It might be that we queued all the m2p grant table			 * hypercalls in a multicall, then m2p_remove_override			 * get called before the multicall has actually been			 * issued. In this case handle is going to -1 because			 * it hasn't been modified yet.			 */			if (map_op->handle == -1)				xen_mc_flush();			/*			 * Now if map_op->handle is negative it means that the			 * hypercall actually returned an error.			 */			if (map_op->handle == GNTST_general_error) {				printk(KERN_WARNING "m2p_remove_override: "						"pfn %lx mfn %lx, failed to modify kernel mappings",						pfn, mfn);				return -1;			}			mcs = xen_mc_entry(					sizeof(struct gnttab_unmap_grant_ref));			unmap_op = mcs.args;			unmap_op->host_addr = map_op->host_addr;			unmap_op->handle = map_op->handle;			unmap_op->dev_bus_addr = 0;			MULTI_grant_table_op(mcs.mc,					GNTTABOP_unmap_grant_ref, unmap_op, 1);			xen_mc_issue(PARAVIRT_LAZY_MMU);			set_pte_at(&init_mm, address, ptep,					pfn_pte(pfn, PAGE_KERNEL));			__flush_tlb_single(address);			map_op->host_addr = 0;		}	} else		set_phys_to_machine(pfn, page->index);	/* p2m(m2p(mfn)) == FOREIGN_FRAME(mfn): the mfn is already present	 * somewhere in this domain, even before being added to the	 * m2p_override (see comment above in m2p_add_override).	 * If there are no other entries in the m2p_override corresponding	 * to this mfn, then remove the FOREIGN_FRAME_BIT from the p2m for	 * the original pfn (the one shared by the frontend): the backend	 * cannot do any IO on this page anymore because it has been	 * unshared. Removing the FOREIGN_FRAME_BIT from the p2m entry of	 * the original pfn causes mfn_to_pfn(mfn) to return the frontend	 * pfn again. */	mfn &= ~FOREIGN_FRAME_BIT;	ret = __get_user(pfn, &machine_to_phys_mapping[mfn]);	if (ret == 0 && get_phys_to_machine(pfn) == FOREIGN_FRAME(mfn) &&			m2p_find_override(mfn) == NULL)		set_phys_to_machine(pfn, mfn);	return 0;}