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

/* * map  one page for ring */static int map_frontend_pages(struct xen_chrif *chrif, grant_ref_t ring_ref){	struct gnttab_map_grant_ref op;    gnttab_set_map_op(&op, (unsigned long)chrif->comms_area->addr, GNTMAP_host_map, ring_ref, chrif->domid);   	if(HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1)){       	printk(KERN_DEBUG "/nxen: dom0: HYPERVISOR map grant ref failed");        return -EFAULT;    }    if (op.status) {		struct gnttab_unmap_grant_ref unop;		gnttab_set_unmap_op(&unop, (unsigned long)chrif->comms_area->addr, GNTMAP_host_map, op.handle);		HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &unop, 1);        printk(KERN_DEBUG "/nxen: dom0: op.status fail");        return op.status;    }	/* record ring_ref and handle */	chrif->shmem_ref = ring_ref;	chrif->shmem_handle = op.handle;    	printk(KERN_DEBUG "/nxen: dom0: map page success, page=%x, handle = %x, status = %x",         (unsigned int)chrif->comms_area->addr, op.handle, op.status);        printk("/nxen: dom0: map frontend pages finished,otherend_id");	return 0;}

tube_t *tube_attach(domid_t peer_domid,		uint32_t page_ref, uint32_t peer_port_rx, uint32_t peer_port_tx, void *data){	tube_t *tb = alloc_tube(0);	if (tb == 0)		return 0;	tube_shared_t *page = tb->page;	tb->page_map.ref = page_ref;	tb->page_map.dom = peer_domid;	tb->page_map.flags = GNTMAP_host_map;	tb->page_map.host_addr = (uint64_t)page;	int rs = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &tb->page_map, 1);	assert(rs == 0);	assert(tb->page_map.status == GNTST_okay);	for (int i = 0; i < TUBE_SLOTS; i++)	{		struct gnttab_map_grant_ref *m = &tb->bufs_map[i];		m->ref = page->tx.slots[i].gref;		m->dom = peer_domid;		m->flags = GNTMAP_host_map;		m->host_addr = (uint64_t)tb->tx_buffers[i];	}	for (int i = 0; i < TUBE_SLOTS; i++)	{		struct gnttab_map_grant_ref *m = &tb->bufs_map[i+TUBE_SLOTS];		m->ref = page->rx.slots[i].gref;		m->dom = peer_domid;		m->flags = GNTMAP_host_map;		m->host_addr = (uint64_t)tb->rx_buffers[i];	}		rs = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, tb->bufs_map, 2*TUBE_SLOTS);	assert(rs == 0);	for (int i = 0; i < 2*TUBE_SLOTS; i++)	{		assert(tb->bufs_map[i].status == GNTST_okay);		rmb();	//dark	}	tb->evtchn_tx = event_bind_interdomain(peer_domid, peer_port_tx);	tb->evtchn_rx = event_bind_interdomain(peer_domid, peer_port_rx);	event_bind(tb->evtchn_rx, tube_int, data);	event_bind(tb->evtchn_tx, tube_send_int, data);	return tb;}

int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,		    struct gnttab_map_grant_ref *kmap_ops,		    struct page **pages, unsigned int count){	int i, ret;	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map_ops, count);	if (ret)		return ret;	for (i = 0; i < count; i++) {		/* Retry eagain maps */		if (map_ops[i].status == GNTST_eagain)			gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, map_ops + i,						&map_ops[i].status, __func__);		if (map_ops[i].status == GNTST_okay) {			struct xen_page_foreign *foreign;			SetPageForeign(pages[i]);			foreign = xen_page_foreign(pages[i]);			foreign->domid = map_ops[i].dom;			foreign->gref = map_ops[i].ref;		}	}	return set_foreign_p2m_mapping(map_ops, kmap_ops, pages, count);}

static int unmap_ring_vfree(struct xenbus_device *dev, struct vm_struct *area,			    unsigned int nr, grant_handle_t handles[]){	unsigned int i;	int err = 0;	for (i = 0; i < nr; ++i) {		struct gnttab_unmap_grant_ref op;		gnttab_set_unmap_op(&op,				    (unsigned long)area->addr + i * PAGE_SIZE,				    GNTMAP_host_map, handles[i]);		if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,					      &op, 1))			BUG();		if (op.status == GNTST_okay)			continue;		xenbus_dev_error(dev, op.status,				 "unmapping page %u (handle %#x)",				 i, handles[i]);		err = -EINVAL;	}	if (!err) {		free_vm_area(area);		kfree(handles);	}	return err;}

void grants_init(void){	unsigned long frames[NR_GRANT_PAGES];	gnttab_setup_table_t op;	op.dom = DOMID_SELF;	op.nr_frames = NR_GRANT_PAGES;	set_xen_guest_handle(op.frame_list, frames);	int rs = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &op, 1);	if (rs < 0)		fatal_error("grants_init: setup_table failed: %d/n", rs);	for (int i = NR_GRANT_ENTRIES-1; i >= NR_RESERVED_ENTRIES; i--)	{		free_list[i] = free_entry;		free_entry = i;	}	grant_entries = mm_alloc_pages(NR_GRANT_PAGES);	if (grant_entries == 0)		fatal_error("grants_init: grant entries page allocation failed/n");	for (int i = 0; i < NR_GRANT_PAGES; i++)	{		unsigned long ma_grant_table = frames[i] << PAGE_SHIFT;		rs = HYPERVISOR_update_va_mapping((unsigned long)grant_entries + i*PAGE_SIZE,			__pte(ma_grant_table | 7), UVMF_INVLPG);		if (rs < 0)			fatal_error("grants_init: update mapping failed: %d/n", rs);	}}

static void gnttab_request_version(void){	int rc;	struct gnttab_set_version gsv;	gsv.version = 1;	rc = HYPERVISOR_grant_table_op(GNTTABOP_set_version, &gsv, 1);	if (rc == 0 && gsv.version == 2) {		grant_table_version = 2;		grefs_per_grant_frame = PAGE_SIZE / sizeof(union grant_entry_v2);		gnttab_interface = &gnttab_v2_ops;	} else if (grant_table_version == 2) {		/*		 * If we've already used version 2 features,		 * but then suddenly discover that they're not		 * available (e.g. migrating to an older		 * version of Xen), almost unbounded badness		 * can happen.		 */		panic("we need grant tables version 2, but only version 1 is available");	} else {		grant_table_version = 1;		grefs_per_grant_frame = PAGE_SIZE / sizeof(struct grant_entry_v1);		gnttab_interface = &gnttab_v1_ops;	}	pr_info("Grant tables using version %d layout/n", grant_table_version);}

static void gnttab_request_version(void){	int rc;	struct gnttab_set_version gsv;	if (xen_hvm_domain())		gsv.version = 1;	else		gsv.version = 2;	rc = HYPERVISOR_grant_table_op(GNTTABOP_set_version, &gsv, 1);	if (rc == 0 && gsv.version == 2) {		grant_table_version = 2;		gnttab_interface = &gnttab_v2_ops;	} else if (grant_table_version == 2) {		/*		 * If we've already used version 2 features,		 * but then suddenly discover that they're not		 * available (e.g. migrating to an older		 * version of Xen), almost unbounded badness		 * can happen.		 */		panic("we need grant tables version 2, but only version 1 is available");	} else {		grant_table_version = 1;		gnttab_interface = &gnttab_v1_ops;	}	printk(KERN_INFO "Grant tables using version %d layout./n",		grant_table_version);}

static int gnttab_map(unsigned int start_idx, unsigned int end_idx){	struct gnttab_setup_table setup;	unsigned long *frames;	unsigned int nr_gframes = end_idx + 1;	int rc;	frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC);	if (!frames)		return -ENOMEM;	setup.dom        = DOMID_SELF;	setup.nr_frames  = nr_gframes;	set_xen_guest_handle(setup.frame_list, frames);	rc = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);	if (rc == -ENOSYS) {		kfree(frames);		return -ENOSYS;	}	BUG_ON(rc || setup.status);	rc = arch_gnttab_map_shared(frames, nr_gframes, max_nr_grant_frames(),				    &shared);	BUG_ON(rc);	kfree(frames);	return 0;}

int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,		      struct gnttab_map_grant_ref *kmap_ops,		      struct page **pages, unsigned int count){	int i, ret;	bool lazy = false;	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap_ops, count);	if (ret)		return ret;	if (xen_feature(XENFEAT_auto_translated_physmap))		return ret;	if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {		arch_enter_lazy_mmu_mode();		lazy = true;	}	for (i = 0; i < count; i++) {		ret = m2p_remove_override(pages[i], kmap_ops ?				       &kmap_ops[i] : NULL);		if (ret)			return ret;	}	if (lazy)		arch_leave_lazy_mmu_mode();	return ret;}

int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,		    struct gnttab_map_grant_ref *kmap_ops,		    struct page **pages, unsigned int count){	int i, ret;	pte_t *pte;	unsigned long mfn;	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map_ops, count);	if (ret)		return ret;	if (xen_feature(XENFEAT_auto_translated_physmap))		return ret;	for (i = 0; i < count; i++) {		/* Do not add to override if the map failed. */		if (map_ops[i].status)			continue;		if (map_ops[i].flags & GNTMAP_contains_pte) {			pte = (pte_t *) (mfn_to_virt(PFN_DOWN(map_ops[i].host_addr)) +				(map_ops[i].host_addr & ~PAGE_MASK));			mfn = pte_mfn(*pte);		} else {			mfn = PFN_DOWN(map_ops[i].dev_bus_addr);		}		ret = m2p_add_override(mfn, pages[i], kmap_ops ?				       &kmap_ops[i] : NULL);		if (ret)			return ret;	}	return ret;}

grant_handle_t map(domid_t friend, 		unsigned int entry, 		void * shared_page, 		grant_handle_t * handle){	/* Set up the mapping operation */	gnttab_map_grant_ref_t map_op;	map_op.host_addr = shared_page;	map_op.flags = GNTMAP_host_map;	map_op.ref = entry;	map_op.dom = friend;	/* Perform the map */	HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op,1);	/* Check if it worked */	if(map_op.status != GNTST_okay)	{		return -1;	}	else 	{		/* Return the handle */		*handle = map_op.handle;		return 0;	}}

int clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,			      struct gnttab_unmap_grant_ref *kunmap_ops,			      struct page **pages, unsigned int count){	int i, ret = 0;	if (xen_feature(XENFEAT_auto_translated_physmap))		return 0;	for (i = 0; i < count; i++) {		unsigned long mfn = __pfn_to_mfn(page_to_pfn(pages[i]));		unsigned long pfn = page_to_pfn(pages[i]);		if (mfn == INVALID_P2M_ENTRY || !(mfn & FOREIGN_FRAME_BIT)) {			ret = -EINVAL;			goto out;		}		set_phys_to_machine(pfn, INVALID_P2M_ENTRY);	}	if (kunmap_ops)		ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref,						kunmap_ops, count);out:	return ret;}

static int_gntmap_map_grant_ref(struct gntmap_entry *entry,                       unsigned long host_addr,                      uint32_t domid,                      uint32_t ref,                      int writable){    struct gnttab_map_grant_ref op;    int rc;    op.ref = (grant_ref_t) ref;    op.dom = (domid_t) domid;    op.host_addr = (uint64_t) host_addr;    op.flags = GNTMAP_host_map;    if (!writable)        op.flags |= GNTMAP_readonly;    rc = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);    if (rc != 0 || op.status != GNTST_okay) {        printk("GNTTABOP_map_grant_ref failed: "               "returned %d, status %" PRId16 "/n",               rc, op.status);        return rc != 0 ? rc : op.status;    }    entry->host_addr = host_addr;    entry->handle = op.handle;    return 0;}

static int map_frontend_page( struct vscsibk_info *info,				unsigned long ring_ref){	struct gnttab_map_grant_ref op;	int err;	gnttab_set_map_op(&op, (unsigned long)info->ring_area->addr,				GNTMAP_host_map, ring_ref,				info->domid);    do {	    err = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);	    BUG_ON(err);        msleep(10);    } while(op.status == GNTST_eagain);	if (op.status) {		printk(KERN_ERR "scsiback: Grant table operation failure !/n");		return op.status;	}	info->shmem_ref    = ring_ref;	info->shmem_handle = op.handle;	return (GNTST_okay);}

static int gnttab_map(unsigned int start_idx, unsigned int end_idx){	struct gnttab_setup_table setup;	unsigned long *frames;	unsigned int nr_gframes = end_idx + 1;	int rc;	if (xen_hvm_domain()) {		struct xen_add_to_physmap xatp;		unsigned int i = end_idx;		rc = 0;		/*		 * Loop backwards, so that the first hypercall has the largest		 * index, ensuring that the table will grow only once.		 */		do {			xatp.domid = DOMID_SELF;			xatp.idx = i;			xatp.space = XENMAPSPACE_grant_table;			xatp.gpfn = (xen_hvm_resume_frames >> PAGE_SHIFT) + i;			rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp);			if (rc != 0) {#ifdef CONFIG_DEBUG_PRINTK				printk(KERN_WARNING						"grant table add_to_physmap failed, err=%d/n", rc);#else				;#endif				break;			}		} while (i-- > start_idx);		return rc;	}	frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC);	if (!frames)		return -ENOMEM;	setup.dom        = DOMID_SELF;	setup.nr_frames  = nr_gframes;	set_xen_guest_handle(setup.frame_list, frames);	rc = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);	if (rc == -ENOSYS) {		kfree(frames);		return -ENOSYS;	}	BUG_ON(rc || setup.status);	rc = arch_gnttab_map_shared(frames, nr_gframes, gnttab_max_grant_frames(),				    &shared);	BUG_ON(rc);	kfree(frames);	return 0;}

static int gnttab_map(unsigned int start_idx, unsigned int end_idx){	struct gnttab_setup_table setup;	xen_pfn_t *frames;	unsigned int nr_gframes = end_idx + 1;	int rc;	if (xen_feature(XENFEAT_auto_translated_physmap)) {		struct xen_add_to_physmap xatp;		unsigned int i = end_idx;		rc = 0;		BUG_ON(xen_auto_xlat_grant_frames.count < nr_gframes);		/*		 * Loop backwards, so that the first hypercall has the largest		 * index, ensuring that the table will grow only once.		 */		do {			xatp.domid = DOMID_SELF;			xatp.idx = i;			xatp.space = XENMAPSPACE_grant_table;			xatp.gpfn = xen_auto_xlat_grant_frames.pfn[i];			rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp);			if (rc != 0) {				pr_warn("grant table add_to_physmap failed, err=%d/n",					rc);				break;			}		} while (i-- > start_idx);		return rc;	}	/* No need for kzalloc as it is initialized in following hypercall	 * GNTTABOP_setup_table.	 */	frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC);	if (!frames)		return -ENOMEM;	setup.dom        = DOMID_SELF;	setup.nr_frames  = nr_gframes;	set_xen_guest_handle(setup.frame_list, frames);	rc = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);	if (rc == -ENOSYS) {		kfree(frames);		return -ENOSYS;	}	BUG_ON(rc || setup.status);	rc = gnttab_interface->map_frames(frames, nr_gframes);	kfree(frames);	return rc;}

voidfini_gnttab(void){    struct gnttab_setup_table setup;    setup.dom = DOMID_SELF;    setup.nr_frames = 0;    HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);}

static void unmap_frontend_page(struct xen_blkif *blkif){	struct gnttab_unmap_grant_ref op;	gnttab_set_unmap_op(&op, (unsigned long)blkif->blk_ring_area->addr,			    GNTMAP_host_map, blkif->shmem_handle);	if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))		BUG();}

/*ARGSUSED*/intxen_map_gref(uint_t cmd, gnttab_map_grant_ref_t *mapop, uint_t count,    boolean_t uvaddr){	long rc;	ASSERT(cmd == GNTTABOP_map_grant_ref);	rc = HYPERVISOR_grant_table_op(cmd, mapop, count);	return (rc);}

void gnttab_batch_copy(struct gnttab_copy *batch, unsigned count){	struct gnttab_copy *op;	if (HYPERVISOR_grant_table_op(GNTTABOP_copy, batch, count))		BUG();	for (op = batch; op < batch + count; op++)		if (op->status == GNTST_eagain)			gnttab_retry_eagain_gop(GNTTABOP_copy, op,						&op->status, __func__);}

/* Disable grant tables */CAMLprim valuecaml_gnttab_fini(value unit){    CAMLparam1(unit);    struct gnttab_setup_table setup;    setup.dom = DOMID_SELF;    setup.nr_frames = 0;    HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);    CAMLreturn(Val_unit);}

static void unmap_frontend_pages(netif_t *netif){	struct gnttab_unmap_grant_ref op;	int ret;	gnttab_set_unmap_op(&op, (unsigned long)netif->tx_comms_area->addr,			    GNTMAP_host_map, netif->tx_shmem_handle);	lock_vm_area(netif->tx_comms_area);	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);	unlock_vm_area(netif->tx_comms_area);	BUG_ON(ret);	gnttab_set_unmap_op(&op, (unsigned long)netif->rx_comms_area->addr,			    GNTMAP_host_map, netif->rx_shmem_handle);	lock_vm_area(netif->rx_comms_area);	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);	unlock_vm_area(netif->rx_comms_area);	BUG_ON(ret);}

static void unmap_frontend_page(struct vscsibk_info *info){	struct gnttab_unmap_grant_ref op;	int err;	gnttab_set_unmap_op(&op, (unsigned long)info->ring_area->addr,				GNTMAP_host_map, info->shmem_handle);	err = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);	BUG_ON(err);}

int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,		      struct gnttab_map_grant_ref *kmap_ops,		      struct page **pages, unsigned int count){	int ret;	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap_ops, count);	if (ret)		return ret;	return clear_foreign_p2m_mapping(unmap_ops, kmap_ops, pages, count);}

static int map_frontend_pages(	netif_t *netif, grant_ref_t tx_ring_ref, grant_ref_t rx_ring_ref){	struct gnttab_map_grant_ref op;	int ret;	gnttab_set_map_op(&op, (unsigned long)netif->tx_comms_area->addr,			  GNTMAP_host_map, tx_ring_ref, netif->domid);    	lock_vm_area(netif->tx_comms_area);	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);	unlock_vm_area(netif->tx_comms_area);	BUG_ON(ret);	if (op.status) { 		DPRINTK(" Gnttab failure mapping tx_ring_ref!/n");		return op.status;	}	netif->tx_shmem_ref    = tx_ring_ref;	netif->tx_shmem_handle = op.handle;	gnttab_set_map_op(&op, (unsigned long)netif->rx_comms_area->addr,			  GNTMAP_host_map, rx_ring_ref, netif->domid);	lock_vm_area(netif->rx_comms_area);	ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);	unlock_vm_area(netif->rx_comms_area);	BUG_ON(ret);	if (op.status) {		DPRINTK(" Gnttab failure mapping rx_ring_ref!/n");		return op.status;	}	netif->rx_shmem_ref    = rx_ring_ref;	netif->rx_shmem_handle = op.handle;	return 0;}

static unsigned int __max_nr_grant_frames(void){	struct gnttab_query_size query;	int rc;	query.dom = DOMID_SELF;	rc = HYPERVISOR_grant_table_op(GNTTABOP_query_size, &query, 1);	if ((rc < 0) || (query.status != GNTST_okay))		return 4; /* Legacy max supported number of frames */	return query.max_nr_frames;}

static void unmap_frontend_page(blkif_t *blkif){	struct gnttab_unmap_grant_ref op;	int ret;	gnttab_set_unmap_op(&op, (unsigned long)blkif->blk_ring_area->addr,			    GNTMAP_host_map, blkif->shmem_handle);	lock_vm_area(blkif->blk_ring_area);	ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);	unlock_vm_area(blkif->blk_ring_area);	BUG_ON(ret);}

void tube_destroy(tube_t *tb){	if (tb->accepting)	{		event_unbind(tb->evtchn_tx);//		for (int i = 0; i < TUBE_SLOTS; i++)//			grants_end_access(tb->page->tx.slots[i].gref);//		for (int i = 0; i < TUBE_SLOTS; i++)//			grants_end_access(tb->page->rx.slots[i].gref);//		grants_end_access(tb->page_ref);	}	else	{		event_unbind(tb->evtchn_rx);		int rs = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, tb->bufs_map, 2*TUBE_SLOTS);		assert(rs == 0);		rs = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &tb->page_map, 1);		assert(rs == 0);	}	nfree(tb->node);}

/* * unmap one page of ring */static void unmap_frontend_pages(struct xen_chrif *chrif){	struct gnttab_unmap_grant_ref unop;		gnttab_set_unmap_op(&unop, (unsigned long)chrif->comms_area->addr, 		GNTMAP_host_map, chrif->shmem_handle);	if(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &unop, 1))		printk(KERN_DEBUG "/nxen:dom0: unmapped shared page failed"); 	free_vm_area(chrif->comms_area);	printk(KERN_DEBUG "/nxen:dom0: unmapped frontend pages finished");}

int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,                    struct gnttab_map_grant_ref *kmap_ops,                    struct page **pages, unsigned int count){    int i, ret;    bool lazy = false;    pte_t *pte;    unsigned long mfn;    ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map_ops, count);    if (ret)        return ret;    /* Retry eagain maps */    for (i = 0; i < count; i++)        if (map_ops[i].status == GNTST_eagain)            gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, map_ops + i,                                    &map_ops[i].status, __func__);    if (xen_feature(XENFEAT_auto_translated_physmap))        return ret;    if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {        arch_enter_lazy_mmu_mode();        lazy = true;    }    for (i = 0; i < count; i++) {        /* Do not add to override if the map failed. */        if (map_ops[i].status)            continue;        if (map_ops[i].flags & GNTMAP_contains_pte) {            pte = (pte_t *) (mfn_to_virt(PFN_DOWN(map_ops[i].host_addr)) +                             (map_ops[i].host_addr & ~PAGE_MASK));            mfn = pte_mfn(*pte);        } else {            mfn = PFN_DOWN(map_ops[i].dev_bus_addr);        }        ret = m2p_add_override(mfn, pages[i], kmap_ops ?                               &kmap_ops[i] : NULL);        if (ret)            goto out;    }out:    if (lazy)        arch_leave_lazy_mmu_mode();    return ret;}