xref: /titanic_51/usr/src/uts/i86xpv/vm/seg_mf.c (revision 878f29a18473c53fcfe3807c019cd8868bff5ae5)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Machine frame segment driver.  This segment driver allows dom0 processes to
29  * map pages of other domains or Xen (e.g. during save/restore).  ioctl()s on
30  * the privcmd driver provide the MFN values backing each mapping, and we map
31  * them into the process's address space at this time.  Demand-faulting is not
32  * supported by this driver due to the requirements upon some of the ioctl()s.
33  */
34 
35 
36 #include <sys/types.h>
37 #include <sys/systm.h>
38 #include <sys/vmsystm.h>
39 #include <sys/mman.h>
40 #include <sys/errno.h>
41 #include <sys/kmem.h>
42 #include <sys/cmn_err.h>
43 #include <sys/vnode.h>
44 #include <sys/conf.h>
45 #include <sys/debug.h>
46 #include <sys/lgrp.h>
47 #include <sys/hypervisor.h>
48 
49 #include <vm/page.h>
50 #include <vm/hat.h>
51 #include <vm/as.h>
52 #include <vm/seg.h>
53 
54 #include <vm/hat_pte.h>
55 #include <vm/hat_i86.h>
56 #include <vm/seg_mf.h>
57 
58 #include <sys/fs/snode.h>
59 
60 #define	VTOCVP(vp)	(VTOS(vp)->s_commonvp)
61 
62 typedef struct segmf_mfn_s {
63 	mfn_t		m_mfn;
64 } segmf_mfn_t;
65 
66 /* g_flags */
67 #define	SEGMF_GFLAGS_WR		0x1
68 #define	SEGMF_GFLAGS_MAPPED	0x2
69 typedef struct segmf_gref_s {
70 	uint64_t	g_ptep;
71 	grant_ref_t	g_gref;
72 	uint32_t	g_flags;
73 	grant_handle_t	g_handle;
74 } segmf_gref_t;
75 
76 typedef union segmf_mu_u {
77 	segmf_mfn_t	m;
78 	segmf_gref_t	g;
79 } segmf_mu_t;
80 
81 typedef enum {
82 	SEGMF_MAP_EMPTY = 0,
83 	SEGMF_MAP_MFN,
84 	SEGMF_MAP_GREF
85 } segmf_map_type_t;
86 
87 typedef struct segmf_map_s {
88 	segmf_map_type_t	t_type;
89 	segmf_mu_t		u;
90 } segmf_map_t;
91 
92 struct segmf_data {
93 	kmutex_t	lock;
94 	struct vnode	*vp;
95 	uchar_t		prot;
96 	uchar_t		maxprot;
97 	size_t		softlockcnt;
98 	domid_t		domid;
99 	segmf_map_t	*map;
100 };
101 
102 static struct seg_ops segmf_ops;
103 
104 static int segmf_fault_gref_range(struct seg *seg, caddr_t addr, size_t len);
105 
106 static struct segmf_data *
107 segmf_data_zalloc(struct seg *seg)
108 {
109 	struct segmf_data *data = kmem_zalloc(sizeof (*data), KM_SLEEP);
110 
111 	mutex_init(&data->lock, "segmf.lock", MUTEX_DEFAULT, NULL);
112 	seg->s_ops = &segmf_ops;
113 	seg->s_data = data;
114 	return (data);
115 }
116 
117 int
118 segmf_create(struct seg *seg, void *args)
119 {
120 	struct segmf_crargs *a = args;
121 	struct segmf_data *data;
122 	struct as *as = seg->s_as;
123 	pgcnt_t i, npages = seg_pages(seg);
124 	int error;
125 
126 	hat_map(as->a_hat, seg->s_base, seg->s_size, HAT_MAP);
127 
128 	data = segmf_data_zalloc(seg);
129 	data->vp = specfind(a->dev, VCHR);
130 	data->prot = a->prot;
131 	data->maxprot = a->maxprot;
132 
133 	data->map = kmem_alloc(npages * sizeof (segmf_map_t), KM_SLEEP);
134 	for (i = 0; i < npages; i++) {
135 		data->map[i].t_type = SEGMF_MAP_EMPTY;
136 	}
137 
138 	error = VOP_ADDMAP(VTOCVP(data->vp), 0, as, seg->s_base, seg->s_size,
139 	    data->prot, data->maxprot, MAP_SHARED, CRED(), NULL);
140 
141 	if (error != 0)
142 		hat_unload(as->a_hat,
143 		    seg->s_base, seg->s_size, HAT_UNLOAD_UNMAP);
144 	return (error);
145 }
146 
147 /*
148  * Duplicate a seg and return new segment in newseg.
149  */
150 static int
151 segmf_dup(struct seg *seg, struct seg *newseg)
152 {
153 	struct segmf_data *data = seg->s_data;
154 	struct segmf_data *ndata;
155 	pgcnt_t npages = seg_pages(newseg);
156 	size_t sz;
157 
158 	ndata = segmf_data_zalloc(newseg);
159 
160 	VN_HOLD(data->vp);
161 	ndata->vp = data->vp;
162 	ndata->prot = data->prot;
163 	ndata->maxprot = data->maxprot;
164 	ndata->domid = data->domid;
165 
166 	sz = npages * sizeof (segmf_map_t);
167 	ndata->map = kmem_alloc(sz, KM_SLEEP);
168 	bcopy(data->map, ndata->map, sz);
169 
170 	return (VOP_ADDMAP(VTOCVP(ndata->vp), 0, newseg->s_as,
171 	    newseg->s_base, newseg->s_size, ndata->prot, ndata->maxprot,
172 	    MAP_SHARED, CRED(), NULL));
173 }
174 
175 /*
176  * We only support unmapping the whole segment, and we automatically unlock
177  * what we previously soft-locked.
178  */
179 static int
180 segmf_unmap(struct seg *seg, caddr_t addr, size_t len)
181 {
182 	struct segmf_data *data = seg->s_data;
183 	offset_t off;
184 
185 	if (addr < seg->s_base || addr + len > seg->s_base + seg->s_size ||
186 	    (len & PAGEOFFSET) || ((uintptr_t)addr & PAGEOFFSET))
187 		panic("segmf_unmap");
188 
189 	if (addr != seg->s_base || len != seg->s_size)
190 		return (ENOTSUP);
191 
192 	hat_unload(seg->s_as->a_hat, addr, len,
193 	    HAT_UNLOAD_UNMAP | HAT_UNLOAD_UNLOCK);
194 
195 	off = (offset_t)seg_page(seg, addr);
196 
197 	ASSERT(data->vp != NULL);
198 
199 	(void) VOP_DELMAP(VTOCVP(data->vp), off, seg->s_as, addr, len,
200 	    data->prot, data->maxprot, MAP_SHARED, CRED(), NULL);
201 
202 	seg_free(seg);
203 	return (0);
204 }
205 
206 static void
207 segmf_free(struct seg *seg)
208 {
209 	struct segmf_data *data = seg->s_data;
210 	pgcnt_t npages = seg_pages(seg);
211 
212 	kmem_free(data->map, npages * sizeof (segmf_map_t));
213 	VN_RELE(data->vp);
214 	mutex_destroy(&data->lock);
215 	kmem_free(data, sizeof (*data));
216 }
217 
218 static int segmf_faultpage_debug = 0;
219 /*ARGSUSED*/
220 static int
221 segmf_faultpage(struct hat *hat, struct seg *seg, caddr_t addr,
222     enum fault_type type, uint_t prot)
223 {
224 	struct segmf_data *data = seg->s_data;
225 	uint_t hat_flags = HAT_LOAD_NOCONSIST;
226 	mfn_t mfn;
227 	x86pte_t pte;
228 	segmf_map_t *map;
229 	uint_t idx;
230 
231 
232 	idx = seg_page(seg, addr);
233 	map = &data->map[idx];
234 	ASSERT(map->t_type == SEGMF_MAP_MFN);
235 
236 	mfn = map->u.m.m_mfn;
237 
238 	if (type == F_SOFTLOCK) {
239 		mutex_enter(&freemem_lock);
240 		data->softlockcnt++;
241 		mutex_exit(&freemem_lock);
242 		hat_flags |= HAT_LOAD_LOCK;
243 	} else
244 		hat_flags |= HAT_LOAD;
245 
246 	if (segmf_faultpage_debug > 0) {
247 		uprintf("segmf_faultpage: addr %p domid %x mfn %lx prot %x\n",
248 		    (void *)addr, data->domid, mfn, prot);
249 		segmf_faultpage_debug--;
250 	}
251 
252 	/*
253 	 * Ask the HAT to load a throwaway mapping to page zero, then
254 	 * overwrite it with our foreign domain mapping. It gets removed
255 	 * later via hat_unload()
256 	 */
257 	hat_devload(hat, addr, MMU_PAGESIZE, (pfn_t)0,
258 	    PROT_READ | HAT_UNORDERED_OK, hat_flags);
259 
260 	pte = mmu_ptob((x86pte_t)mfn) | PT_VALID | PT_USER | PT_FOREIGN;
261 	if (prot & PROT_WRITE)
262 		pte |= PT_WRITABLE;
263 
264 	if (HYPERVISOR_update_va_mapping_otherdomain((uintptr_t)addr, pte,
265 	    UVMF_INVLPG | UVMF_ALL, data->domid) != 0) {
266 		hat_flags = HAT_UNLOAD_UNMAP;
267 
268 		if (type == F_SOFTLOCK) {
269 			hat_flags |= HAT_UNLOAD_UNLOCK;
270 			mutex_enter(&freemem_lock);
271 			data->softlockcnt--;
272 			mutex_exit(&freemem_lock);
273 		}
274 
275 		hat_unload(hat, addr, MMU_PAGESIZE, hat_flags);
276 		return (FC_MAKE_ERR(EFAULT));
277 	}
278 
279 	return (0);
280 }
281 
282 static int
283 seg_rw_to_prot(enum seg_rw rw)
284 {
285 	switch (rw) {
286 	case S_READ:
287 		return (PROT_READ);
288 	case S_WRITE:
289 		return (PROT_WRITE);
290 	case S_EXEC:
291 		return (PROT_EXEC);
292 	case S_OTHER:
293 	default:
294 		break;
295 	}
296 	return (PROT_READ | PROT_WRITE | PROT_EXEC);
297 }
298 
299 static void
300 segmf_softunlock(struct hat *hat, struct seg *seg, caddr_t addr, size_t len)
301 {
302 	struct segmf_data *data = seg->s_data;
303 
304 	hat_unlock(hat, addr, len);
305 
306 	mutex_enter(&freemem_lock);
307 	ASSERT(data->softlockcnt >= btopr(len));
308 	data->softlockcnt -= btopr(len);
309 	mutex_exit(&freemem_lock);
310 
311 	if (data->softlockcnt == 0) {
312 		struct as *as = seg->s_as;
313 
314 		if (AS_ISUNMAPWAIT(as)) {
315 			mutex_enter(&as->a_contents);
316 			if (AS_ISUNMAPWAIT(as)) {
317 				AS_CLRUNMAPWAIT(as);
318 				cv_broadcast(&as->a_cv);
319 			}
320 			mutex_exit(&as->a_contents);
321 		}
322 	}
323 }
324 
325 static int
326 segmf_fault_range(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
327     enum fault_type type, enum seg_rw rw)
328 {
329 	struct segmf_data *data = seg->s_data;
330 	int error = 0;
331 	caddr_t a;
332 
333 	if ((data->prot & seg_rw_to_prot(rw)) == 0)
334 		return (FC_PROT);
335 
336 	/* loop over the address range handling each fault */
337 
338 	for (a = addr; a < addr + len; a += PAGESIZE) {
339 		error = segmf_faultpage(hat, seg, a, type, data->prot);
340 		if (error != 0)
341 			break;
342 	}
343 
344 	if (error != 0 && type == F_SOFTLOCK) {
345 		size_t done = (size_t)(a - addr);
346 
347 		/*
348 		 * Undo what's been done so far.
349 		 */
350 		if (done > 0)
351 			segmf_softunlock(hat, seg, addr, done);
352 	}
353 
354 	return (error);
355 }
356 
357 /*
358  * We never demand-fault for seg_mf.
359  */
360 /*ARGSUSED*/
361 static int
362 segmf_fault(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
363     enum fault_type type, enum seg_rw rw)
364 {
365 	return (FC_MAKE_ERR(EFAULT));
366 }
367 
368 /*ARGSUSED*/
369 static int
370 segmf_faulta(struct seg *seg, caddr_t addr)
371 {
372 	return (0);
373 }
374 
375 /*ARGSUSED*/
376 static int
377 segmf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
378 {
379 	return (EINVAL);
380 }
381 
382 /*ARGSUSED*/
383 static int
384 segmf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
385 {
386 	return (EINVAL);
387 }
388 
389 /*ARGSUSED*/
390 static int
391 segmf_kluster(struct seg *seg, caddr_t addr, ssize_t delta)
392 {
393 	return (-1);
394 }
395 
396 /*ARGSUSED*/
397 static int
398 segmf_sync(struct seg *seg, caddr_t addr, size_t len, int attr, uint_t flags)
399 {
400 	return (0);
401 }
402 
403 /*
404  * XXPV	Hmm.  Should we say that mf mapping are "in core?"
405  */
406 
407 /*ARGSUSED*/
408 static size_t
409 segmf_incore(struct seg *seg, caddr_t addr, size_t len, char *vec)
410 {
411 	size_t v;
412 
413 	for (v = 0, len = (len + PAGEOFFSET) & PAGEMASK; len;
414 	    len -= PAGESIZE, v += PAGESIZE)
415 		*vec++ = 1;
416 	return (v);
417 }
418 
419 /*ARGSUSED*/
420 static int
421 segmf_lockop(struct seg *seg, caddr_t addr,
422     size_t len, int attr, int op, ulong_t *lockmap, size_t pos)
423 {
424 	return (0);
425 }
426 
427 static int
428 segmf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
429 {
430 	struct segmf_data *data = seg->s_data;
431 	pgcnt_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
432 
433 	if (pgno != 0) {
434 		do
435 			protv[--pgno] = data->prot;
436 		while (pgno != 0)
437 			;
438 	}
439 	return (0);
440 }
441 
442 static u_offset_t
443 segmf_getoffset(struct seg *seg, caddr_t addr)
444 {
445 	return (addr - seg->s_base);
446 }
447 
448 /*ARGSUSED*/
449 static int
450 segmf_gettype(struct seg *seg, caddr_t addr)
451 {
452 	return (MAP_SHARED);
453 }
454 
455 /*ARGSUSED1*/
456 static int
457 segmf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
458 {
459 	struct segmf_data *data = seg->s_data;
460 
461 	*vpp = VTOCVP(data->vp);
462 	return (0);
463 }
464 
465 /*ARGSUSED*/
466 static int
467 segmf_advise(struct seg *seg, caddr_t addr, size_t len, uint_t behav)
468 {
469 	return (0);
470 }
471 
472 /*ARGSUSED*/
473 static void
474 segmf_dump(struct seg *seg)
475 {}
476 
477 /*ARGSUSED*/
478 static int
479 segmf_pagelock(struct seg *seg, caddr_t addr, size_t len,
480     struct page ***ppp, enum lock_type type, enum seg_rw rw)
481 {
482 	return (ENOTSUP);
483 }
484 
485 /*ARGSUSED*/
486 static int
487 segmf_setpagesize(struct seg *seg, caddr_t addr, size_t len, uint_t szc)
488 {
489 	return (ENOTSUP);
490 }
491 
492 static int
493 segmf_getmemid(struct seg *seg, caddr_t addr, memid_t *memid)
494 {
495 	struct segmf_data *data = seg->s_data;
496 
497 	memid->val[0] = (uintptr_t)VTOCVP(data->vp);
498 	memid->val[1] = (uintptr_t)seg_page(seg, addr);
499 	return (0);
500 }
501 
502 /*ARGSUSED*/
503 static lgrp_mem_policy_info_t *
504 segmf_getpolicy(struct seg *seg, caddr_t addr)
505 {
506 	return (NULL);
507 }
508 
509 /*ARGSUSED*/
510 static int
511 segmf_capable(struct seg *seg, segcapability_t capability)
512 {
513 	return (0);
514 }
515 
516 /*
517  * Add a set of contiguous foreign MFNs to the segment. soft-locking them.  The
518  * pre-faulting is necessary due to live migration; in particular we must
519  * return an error in response to IOCTL_PRIVCMD_MMAPBATCH rather than faulting
520  * later on a bad MFN.  Whilst this isn't necessary for the other MMAP
521  * ioctl()s, we lock them too, as they should be transitory.
522  */
523 int
524 segmf_add_mfns(struct seg *seg, caddr_t addr, mfn_t mfn,
525     pgcnt_t pgcnt, domid_t domid)
526 {
527 	struct segmf_data *data = seg->s_data;
528 	pgcnt_t base;
529 	faultcode_t fc;
530 	pgcnt_t i;
531 	int error = 0;
532 
533 	if (seg->s_ops != &segmf_ops)
534 		return (EINVAL);
535 
536 	/*
537 	 * Don't mess with dom0.
538 	 *
539 	 * Only allow the domid to be set once for the segment.
540 	 * After that attempts to add mappings to this segment for
541 	 * other domains explicitly fails.
542 	 */
543 
544 	if (domid == 0 || domid == DOMID_SELF)
545 		return (EACCES);
546 
547 	mutex_enter(&data->lock);
548 
549 	if (data->domid == 0)
550 		data->domid = domid;
551 
552 	if (data->domid != domid) {
553 		error = EINVAL;
554 		goto out;
555 	}
556 
557 	base = seg_page(seg, addr);
558 
559 	for (i = 0; i < pgcnt; i++) {
560 		data->map[base + i].t_type = SEGMF_MAP_MFN;
561 		data->map[base + i].u.m.m_mfn = mfn++;
562 	}
563 
564 	fc = segmf_fault_range(seg->s_as->a_hat, seg, addr,
565 	    pgcnt * MMU_PAGESIZE, F_SOFTLOCK, S_OTHER);
566 
567 	if (fc != 0) {
568 		error = fc_decode(fc);
569 		for (i = 0; i < pgcnt; i++) {
570 			data->map[base + i].t_type = SEGMF_MAP_EMPTY;
571 		}
572 	}
573 
574 out:
575 	mutex_exit(&data->lock);
576 	return (error);
577 }
578 
579 int
580 segmf_add_grefs(struct seg *seg, caddr_t addr, uint_t flags,
581     grant_ref_t *grefs, uint_t cnt, domid_t domid)
582 {
583 	struct segmf_data *data;
584 	segmf_map_t *map;
585 	faultcode_t fc;
586 	uint_t idx;
587 	uint_t i;
588 	int e;
589 
590 	if (seg->s_ops != &segmf_ops)
591 		return (EINVAL);
592 
593 	/*
594 	 * Don't mess with dom0.
595 	 *
596 	 * Only allow the domid to be set once for the segment.
597 	 * After that attempts to add mappings to this segment for
598 	 * other domains explicitly fails.
599 	 */
600 
601 	if (domid == 0 || domid == DOMID_SELF)
602 		return (EACCES);
603 
604 	data = seg->s_data;
605 	idx = seg_page(seg, addr);
606 	map = &data->map[idx];
607 	e = 0;
608 
609 	mutex_enter(&data->lock);
610 
611 	if (data->domid == 0)
612 		data->domid = domid;
613 
614 	if (data->domid != domid) {
615 		e = EINVAL;
616 		goto out;
617 	}
618 
619 	/* store away the grefs passed in then fault in the pages */
620 	for (i = 0; i < cnt; i++) {
621 		map[i].t_type = SEGMF_MAP_GREF;
622 		map[i].u.g.g_gref = grefs[i];
623 		map[i].u.g.g_handle = 0;
624 		map[i].u.g.g_flags = 0;
625 		if (flags & SEGMF_GREF_WR) {
626 			map[i].u.g.g_flags |= SEGMF_GFLAGS_WR;
627 		}
628 	}
629 	fc = segmf_fault_gref_range(seg, addr, cnt);
630 	if (fc != 0) {
631 		e = fc_decode(fc);
632 		for (i = 0; i < cnt; i++) {
633 			data->map[i].t_type = SEGMF_MAP_EMPTY;
634 		}
635 	}
636 
637 out:
638 	mutex_exit(&data->lock);
639 	return (e);
640 }
641 
642 int
643 segmf_release_grefs(struct seg *seg, caddr_t addr, uint_t cnt)
644 {
645 	gnttab_unmap_grant_ref_t mapop[SEGMF_MAX_GREFS];
646 	struct segmf_data *data;
647 	segmf_map_t *map;
648 	uint_t idx;
649 	long e;
650 	int i;
651 	int n;
652 
653 
654 	if (cnt > SEGMF_MAX_GREFS) {
655 		return (-1);
656 	}
657 
658 	idx = seg_page(seg, addr);
659 	data = seg->s_data;
660 	map = &data->map[idx];
661 
662 	bzero(mapop, sizeof (gnttab_unmap_grant_ref_t) * cnt);
663 
664 	/*
665 	 * for each entry which isn't empty and is currently mapped,
666 	 * set it up for an unmap then mark them empty.
667 	 */
668 	n = 0;
669 	for (i = 0; i < cnt; i++) {
670 		ASSERT(map[i].t_type != SEGMF_MAP_MFN);
671 		if ((map[i].t_type == SEGMF_MAP_GREF) &&
672 		    (map[i].u.g.g_flags & SEGMF_GFLAGS_MAPPED)) {
673 			mapop[n].handle = map[i].u.g.g_handle;
674 			mapop[n].host_addr = map[i].u.g.g_ptep;
675 			mapop[n].dev_bus_addr = 0;
676 			n++;
677 		}
678 		map[i].t_type = SEGMF_MAP_EMPTY;
679 	}
680 
681 	/* if there's nothing to unmap, just return */
682 	if (n == 0) {
683 		return (0);
684 	}
685 
686 	e = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &mapop, n);
687 	if (e != 0) {
688 		return (-1);
689 	}
690 
691 	return (0);
692 }
693 
694 
695 void
696 segmf_add_gref_pte(struct seg *seg, caddr_t addr, uint64_t pte_ma)
697 {
698 	struct segmf_data *data;
699 	uint_t idx;
700 
701 	idx = seg_page(seg, addr);
702 	data = seg->s_data;
703 
704 	data->map[idx].u.g.g_ptep = pte_ma;
705 }
706 
707 
708 static int
709 segmf_fault_gref_range(struct seg *seg, caddr_t addr, size_t cnt)
710 {
711 	gnttab_map_grant_ref_t mapop[SEGMF_MAX_GREFS];
712 	struct segmf_data *data;
713 	segmf_map_t *map;
714 	uint_t idx;
715 	int e;
716 	int i;
717 
718 
719 	if (cnt > SEGMF_MAX_GREFS) {
720 		return (-1);
721 	}
722 
723 	data = seg->s_data;
724 	idx = seg_page(seg, addr);
725 	map = &data->map[idx];
726 
727 	bzero(mapop, sizeof (gnttab_map_grant_ref_t) * cnt);
728 
729 	ASSERT(map->t_type == SEGMF_MAP_GREF);
730 
731 	/*
732 	 * map in each page passed in into the user apps AS. We do this by
733 	 * passing the MA of the actual pte of the mapping to the hypervisor.
734 	 */
735 	for (i = 0; i < cnt; i++) {
736 		mapop[i].host_addr = map[i].u.g.g_ptep;
737 		mapop[i].dom = data->domid;
738 		mapop[i].ref = map[i].u.g.g_gref;
739 		mapop[i].flags = GNTMAP_host_map | GNTMAP_application_map |
740 		    GNTMAP_contains_pte;
741 		if (!(map[i].u.g.g_flags & SEGMF_GFLAGS_WR)) {
742 			mapop[i].flags |= GNTMAP_readonly;
743 		}
744 	}
745 	e = xen_map_gref(GNTTABOP_map_grant_ref, mapop, cnt, B_TRUE);
746 	if ((e != 0) || (mapop[0].status != GNTST_okay)) {
747 		return (FC_MAKE_ERR(EFAULT));
748 	}
749 
750 	/* save handle for segmf_release_grefs() and mark it as mapped */
751 	for (i = 0; i < cnt; i++) {
752 		ASSERT(mapop[i].status == GNTST_okay);
753 		map[i].u.g.g_handle = mapop[i].handle;
754 		map[i].u.g.g_flags |= SEGMF_GFLAGS_MAPPED;
755 	}
756 
757 	return (0);
758 }
759 
760 static struct seg_ops segmf_ops = {
761 	segmf_dup,
762 	segmf_unmap,
763 	segmf_free,
764 	segmf_fault,
765 	segmf_faulta,
766 	segmf_setprot,
767 	segmf_checkprot,
768 	(int (*)())segmf_kluster,
769 	(size_t (*)(struct seg *))NULL,	/* swapout */
770 	segmf_sync,
771 	segmf_incore,
772 	segmf_lockop,
773 	segmf_getprot,
774 	segmf_getoffset,
775 	segmf_gettype,
776 	segmf_getvp,
777 	segmf_advise,
778 	segmf_dump,
779 	segmf_pagelock,
780 	segmf_setpagesize,
781 	segmf_getmemid,
782 	segmf_getpolicy,
783 	segmf_capable
784 };
785