xref: /illumos-gate/usr/src/uts/sun4v/io/ds_pri.c (revision de710d24)
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  * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*
26  * sun4v domain services PRI driver
27  */
28 
29 #include <sys/types.h>
30 #include <sys/file.h>
31 #include <sys/errno.h>
32 #include <sys/open.h>
33 #include <sys/cred.h>
34 #include <sys/uio.h>
35 #include <sys/stat.h>
36 #include <sys/ksynch.h>
37 #include <sys/modctl.h>
38 #include <sys/conf.h>
39 #include <sys/devops.h>
40 #include <sys/debug.h>
41 #include <sys/cmn_err.h>
42 #include <sys/ddi.h>
43 #include <sys/sunddi.h>
44 #include <sys/ds.h>
45 #include <sys/hypervisor_api.h>
46 #include <sys/machsystm.h>
47 #include <sys/sysmacros.h>
48 #include <sys/hsvc.h>
49 #include <sys/bitmap.h>
50 #include <sys/ds_pri.h>
51 
52 static uint_t ds_pri_debug = 0;
53 #define	DS_PRI_DBG	if (ds_pri_debug) printf
54 
55 #define	DS_PRI_NAME	"ds_pri"
56 
57 #define	TEST_HARNESS
58 #ifdef TEST_HARNESS
59 #define	DS_PRI_MAX_PRI_SIZE	(64 * 1024)
60 
61 #define	DSIOC_TEST_REG	97
62 #define	DSIOC_TEST_UNREG	98
63 #define	DSIOC_TEST_DATA	99
64 
65 struct ds_pri_test_data {
66 	size_t		size;
67 	void		*data;
68 };
69 
70 struct ds_pri_test_data32 {
71 	size32_t	size;
72 	caddr32_t	data;
73 };
74 #endif /* TEST_HARNESS */
75 
76 typedef	enum {
77 	DS_PRI_REQUEST	= 0,
78 	DS_PRI_DATA	= 1,
79 	DS_PRI_UPDATE	= 2
80 } ds_pri_msg_type_t;
81 
82 typedef	struct {
83 	struct {
84 		uint64_t	seq_num;
85 		uint64_t	type;
86 	} hdr;
87 	uint8_t		data[1];
88 } ds_pri_msg_t;
89 
90 /*
91  * The following are bit field flags. No service implies no DS PRI and
92  * no outstanding request.
93  */
94 typedef enum {
95 	DS_PRI_NO_SERVICE = 0x0,
96 	DS_PRI_HAS_SERVICE = 0x1,
97 	DS_PRI_REQUESTED = 0x2,
98 	DS_PRI_HAS_PRI = 0x4
99 } ds_pri_flags_t;
100 
101 struct ds_pri_state {
102 	dev_info_t	*dip;
103 	int		instance;
104 
105 	kmutex_t	lock;
106 	kcondvar_t	cv;
107 
108 	/* PRI/DS */
109 	ds_pri_flags_t	state;
110 	uint64_t	gencount;
111 	ds_svc_hdl_t	ds_pri_handle;
112 	void		*ds_pri;
113 	size_t		ds_pri_len;
114 	uint64_t	req_id;
115 	uint64_t	last_req_id;
116 	int		num_opens;
117 };
118 
119 typedef struct ds_pri_state ds_pri_state_t;
120 
121 static void *ds_pri_statep;
122 
123 static void request_pri(ds_pri_state_t *sp);
124 static uint64_t ds_get_hv_pri(ds_pri_state_t *sp);
125 
126 static int ds_pri_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
127 static int ds_pri_attach(dev_info_t *, ddi_attach_cmd_t);
128 static int ds_pri_detach(dev_info_t *, ddi_detach_cmd_t);
129 static int ds_pri_open(dev_t *, int, int, cred_t *);
130 static int ds_pri_close(dev_t, int, int, cred_t *);
131 static int ds_pri_read(dev_t, struct uio *, cred_t *);
132 static int ds_pri_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
133 
134 /*
135  * DS Callbacks
136  */
137 static void ds_pri_reg_handler(ds_cb_arg_t, ds_ver_t *, ds_svc_hdl_t);
138 static void ds_pri_unreg_handler(ds_cb_arg_t arg);
139 static void ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);
140 
141 /*
142  * PRI DS capability registration
143  */
144 
145 static ds_ver_t ds_pri_ver_1_0 = { 1, 0 };
146 
147 static ds_capability_t ds_pri_cap = {
148 	"pri",
149 	&ds_pri_ver_1_0,
150 	1
151 };
152 
153 /*
154  * PRI DS Client callback vector
155  */
156 static ds_clnt_ops_t ds_pri_ops = {
157 	ds_pri_reg_handler,	/* ds_reg_cb */
158 	ds_pri_unreg_handler,	/* ds_unreg_cb */
159 	ds_pri_data_handler,	/* ds_data_cb */
160 	NULL			/* cb_arg */
161 };
162 
163 /*
164  * DS PRI driver Ops Vector
165  */
166 static struct cb_ops ds_pri_cb_ops = {
167 	ds_pri_open,		/* cb_open */
168 	ds_pri_close,		/* cb_close */
169 	nodev,			/* cb_strategy */
170 	nodev,			/* cb_print */
171 	nodev,			/* cb_dump */
172 	ds_pri_read,		/* cb_read */
173 	nodev,			/* cb_write */
174 	ds_pri_ioctl,		/* cb_ioctl */
175 	nodev,			/* cb_devmap */
176 	nodev,			/* cb_mmap */
177 	nodev,			/* cb_segmap */
178 	nochpoll,		/* cb_chpoll */
179 	ddi_prop_op,		/* cb_prop_op */
180 	(struct streamtab *)NULL, /* cb_str */
181 	D_MP | D_64BIT,		/* cb_flag */
182 	CB_REV,			/* cb_rev */
183 	nodev,			/* cb_aread */
184 	nodev			/* cb_awrite */
185 };
186 
187 static struct dev_ops ds_pri_dev_ops = {
188 	DEVO_REV,		/* devo_rev */
189 	0,			/* devo_refcnt */
190 	ds_pri_getinfo,		/* devo_getinfo */
191 	nulldev,		/* devo_identify */
192 	nulldev,		/* devo_probe */
193 	ds_pri_attach,		/* devo_attach */
194 	ds_pri_detach,		/* devo_detach */
195 	nodev,			/* devo_reset */
196 	&ds_pri_cb_ops,		/* devo_cb_ops */
197 	(struct bus_ops *)NULL,	/* devo_bus_ops */
198 	nulldev,		/* devo_power */
199 	ddi_quiesce_not_needed,		/* devo_quiesce */
200 };
201 
202 static struct modldrv modldrv = {
203 	&mod_driverops,
204 	"Domain Services PRI Driver",
205 	&ds_pri_dev_ops
206 };
207 
208 static struct modlinkage modlinkage = {
209 	MODREV_1,
210 	(void *)&modldrv,
211 	NULL
212 };
213 
214 static boolean_t hsvc_pboot_available = B_FALSE;
215 static hsvc_info_t pboot_hsvc = {
216 	HSVC_REV_1, NULL, HSVC_GROUP_PBOOT, 1, 0, NULL
217 };
218 
219 int
_init(void)220 _init(void)
221 {
222 	int retval;
223 	uint64_t	hsvc_pboot_minor;
224 	uint64_t	status;
225 
226 	status = hsvc_register(&pboot_hsvc, &hsvc_pboot_minor);
227 	if (status == H_EOK) {
228 		hsvc_pboot_available = B_TRUE;
229 	} else {
230 		DS_PRI_DBG("hypervisor services not negotiated "
231 		    "for group number: 0x%lx errorno: 0x%lx\n",
232 		    pboot_hsvc.hsvc_group, status);
233 	}
234 
235 	retval = ddi_soft_state_init(&ds_pri_statep,
236 	    sizeof (ds_pri_state_t), 0);
237 	if (retval != 0)
238 		return (retval);
239 
240 	retval = mod_install(&modlinkage);
241 	if (retval != 0) {
242 		ddi_soft_state_fini(&ds_pri_statep);
243 		return (retval);
244 	}
245 
246 	return (retval);
247 }
248 
249 
250 int
_info(struct modinfo * modinfop)251 _info(struct modinfo *modinfop)
252 {
253 	return (mod_info(&modlinkage, modinfop));
254 }
255 
256 
257 int
_fini(void)258 _fini(void)
259 {
260 	int retval;
261 
262 	if ((retval = mod_remove(&modlinkage)) != 0)
263 		return (retval);
264 
265 	ddi_soft_state_fini(&ds_pri_statep);
266 
267 	if (hsvc_pboot_available)
268 		(void) hsvc_unregister(&pboot_hsvc);
269 
270 	return (retval);
271 }
272 
273 
274 /*ARGSUSED*/
275 static int
ds_pri_getinfo(dev_info_t * dip,ddi_info_cmd_t cmd,void * arg,void ** resultp)276 ds_pri_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
277 {
278 	ds_pri_state_t *sp;
279 	int retval = DDI_FAILURE;
280 
281 	ASSERT(resultp != NULL);
282 
283 	switch (cmd) {
284 	case DDI_INFO_DEVT2DEVINFO:
285 		sp = ddi_get_soft_state(ds_pri_statep, getminor((dev_t)arg));
286 		if (sp != NULL) {
287 			*resultp = sp->dip;
288 			retval = DDI_SUCCESS;
289 		} else
290 			*resultp = NULL;
291 		break;
292 
293 	case DDI_INFO_DEVT2INSTANCE:
294 		*resultp = (void *)(uintptr_t)getminor((dev_t)arg);
295 		retval = DDI_SUCCESS;
296 		break;
297 
298 	default:
299 		break;
300 	}
301 
302 	return (retval);
303 }
304 
305 
306 static int
ds_pri_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)307 ds_pri_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
308 {
309 	int instance;
310 	ds_pri_state_t *sp;
311 	int rv;
312 	uint64_t status;
313 
314 	switch (cmd) {
315 	case DDI_ATTACH:
316 		break;
317 
318 	case DDI_RESUME:
319 		return (DDI_SUCCESS);
320 
321 	default:
322 		return (DDI_FAILURE);
323 	}
324 
325 	instance = ddi_get_instance(dip);
326 
327 	if (ddi_soft_state_zalloc(ds_pri_statep, instance) !=
328 	    DDI_SUCCESS) {
329 		cmn_err(CE_WARN, "%s@%d: Unable to allocate state",
330 		    DS_PRI_NAME, instance);
331 		return (DDI_FAILURE);
332 	}
333 	sp = ddi_get_soft_state(ds_pri_statep, instance);
334 
335 	mutex_init(&sp->lock, NULL, MUTEX_DEFAULT, NULL);
336 	cv_init(&sp->cv, NULL, CV_DEFAULT, NULL);
337 
338 	if (ddi_create_minor_node(dip, DS_PRI_NAME, S_IFCHR, instance,
339 	    DDI_PSEUDO, 0) != DDI_SUCCESS) {
340 		cmn_err(CE_WARN, "%s@%d: Unable to create minor node",
341 		    DS_PRI_NAME, instance);
342 		goto fail;
343 	}
344 
345 	if (ds_pri_ops.cb_arg != NULL)
346 		goto fail;
347 	ds_pri_ops.cb_arg = dip;
348 
349 	sp->state = DS_PRI_NO_SERVICE;
350 
351 	/* Until the service registers the handle is invalid */
352 	sp->ds_pri_handle = DS_INVALID_HDL;
353 
354 	sp->ds_pri = NULL;
355 	sp->ds_pri_len = 0;
356 	sp->req_id = 0;
357 	sp->num_opens = 0;
358 
359 	/*
360 	 * See if we can get the static hv pri data. Static pri data
361 	 * is only available for privileged domains.
362 	 */
363 	if (hsvc_pboot_available) {
364 		if ((status = ds_get_hv_pri(sp)) != 0) {
365 			cmn_err(CE_NOTE, "ds_get_hv_pri failed: 0x%lx", status);
366 		}
367 	}
368 
369 	if ((rv = ds_cap_init(&ds_pri_cap, &ds_pri_ops)) != 0) {
370 		cmn_err(CE_NOTE, "ds_cap_init failed: %d", rv);
371 		goto fail;
372 	}
373 
374 	ddi_report_dev(dip);
375 
376 	return (DDI_SUCCESS);
377 
378 fail:
379 	if (sp->ds_pri)
380 		kmem_free(sp->ds_pri, sp->ds_pri_len);
381 	ddi_remove_minor_node(dip, NULL);
382 	cv_destroy(&sp->cv);
383 	mutex_destroy(&sp->lock);
384 	ddi_soft_state_free(ds_pri_statep, instance);
385 	return (DDI_FAILURE);
386 
387 }
388 
389 
390 /*ARGSUSED*/
391 static int
ds_pri_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)392 ds_pri_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
393 {
394 	ds_pri_state_t *sp;
395 	int instance;
396 	int rv;
397 
398 	instance = ddi_get_instance(dip);
399 	sp = ddi_get_soft_state(ds_pri_statep, instance);
400 
401 	switch (cmd) {
402 	case DDI_DETACH:
403 		break;
404 
405 	case DDI_SUSPEND:
406 		return (DDI_SUCCESS);
407 
408 	default:
409 		return (DDI_FAILURE);
410 	}
411 
412 	/* This really shouldn't fail - but check anyway */
413 	if ((rv = ds_cap_fini(&ds_pri_cap)) != 0) {
414 		cmn_err(CE_WARN, "ds_cap_fini failed: %d", rv);
415 	}
416 
417 	if (sp != NULL && sp->ds_pri_len != 0)
418 		kmem_free(sp->ds_pri, sp->ds_pri_len);
419 
420 	ds_pri_ops.cb_arg = NULL;
421 
422 	ddi_remove_minor_node(dip, NULL);
423 	cv_destroy(&sp->cv);
424 	mutex_destroy(&sp->lock);
425 	ddi_soft_state_free(ds_pri_statep, instance);
426 
427 	return (DDI_SUCCESS);
428 }
429 
430 
431 /*ARGSUSED*/
432 static int
ds_pri_open(dev_t * devp,int flag,int otyp,cred_t * credp)433 ds_pri_open(dev_t *devp, int flag, int otyp, cred_t *credp)
434 {
435 	ds_pri_state_t *sp;
436 	int instance;
437 
438 	if (otyp != OTYP_CHR)
439 		return (EINVAL);
440 
441 	instance = getminor(*devp);
442 	sp = ddi_get_soft_state(ds_pri_statep, instance);
443 	if (sp == NULL)
444 		return (ENXIO);
445 
446 	mutex_enter(&sp->lock);
447 
448 	/*
449 	 * Proceed if we have PRI data (possibly obtained from
450 	 * static HV PRI or last pushed DS PRI data update).
451 	 * If no PRI data and we have no DS PRI service then this
452 	 * means that PRI DS has never called the registration callback.
453 	 * A while loop is necessary as we might have been woken up
454 	 * prematurely, e.g., due to a debugger or "pstack" etc.
455 	 * Wait here and the callback will signal us when it has completed
456 	 * its work.
457 	 */
458 	if (!(sp->state & DS_PRI_HAS_PRI)) {
459 		while (!(sp->state & DS_PRI_HAS_SERVICE)) {
460 			if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
461 				mutex_exit(&sp->lock);
462 				return (EINTR);
463 			}
464 		}
465 	}
466 
467 	sp->num_opens++;
468 	mutex_exit(&sp->lock);
469 
470 	DS_PRI_DBG("ds_pri_open: state = 0x%x\n", sp->state);
471 
472 	return (0);
473 }
474 
475 
476 /*ARGSUSED*/
477 static int
ds_pri_close(dev_t dev,int flag,int otyp,cred_t * credp)478 ds_pri_close(dev_t dev, int flag, int otyp, cred_t *credp)
479 {
480 	int instance;
481 	ds_pri_state_t *sp;
482 
483 	if (otyp != OTYP_CHR)
484 		return (EINVAL);
485 
486 	DS_PRI_DBG("ds_pri_close\n");
487 
488 	instance = getminor(dev);
489 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
490 		return (ENXIO);
491 
492 	mutex_enter(&sp->lock);
493 	if (!(sp->state & DS_PRI_HAS_SERVICE)) {
494 		mutex_exit(&sp->lock);
495 		return (0);
496 	}
497 
498 	if (--sp->num_opens > 0) {
499 		mutex_exit(&sp->lock);
500 		return (0);
501 	}
502 
503 	sp->state &= ~DS_PRI_REQUESTED;
504 	mutex_exit(&sp->lock);
505 	return (0);
506 }
507 
508 
509 /*ARGSUSED*/
510 static int
ds_pri_read(dev_t dev,struct uio * uiop,cred_t * credp)511 ds_pri_read(dev_t dev, struct uio *uiop, cred_t *credp)
512 {
513 	ds_pri_state_t *sp;
514 	int instance;
515 	size_t len;
516 	int retval;
517 	caddr_t tmpbufp;
518 	offset_t off = uiop->uio_offset;
519 
520 	instance = getminor(dev);
521 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
522 		return (ENXIO);
523 
524 	len = uiop->uio_resid;
525 
526 	if (len == 0)
527 		return (0);
528 
529 	mutex_enter(&sp->lock);
530 
531 	DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);
532 
533 	/* block or bail if there is no current PRI */
534 	if (!(sp->state & DS_PRI_HAS_PRI)) {
535 		DS_PRI_DBG("ds_pri_read: no PRI held\n");
536 
537 		if (uiop->uio_fmode & (FNDELAY | FNONBLOCK)) {
538 			mutex_exit(&sp->lock);
539 			return (EAGAIN);
540 		}
541 
542 		while (!(sp->state & DS_PRI_HAS_PRI)) {
543 			DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);
544 			request_pri(sp);
545 			if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
546 				mutex_exit(&sp->lock);
547 				return (EINTR);
548 			}
549 		}
550 	}
551 
552 	if (len > sp->ds_pri_len)
553 		len = sp->ds_pri_len;
554 
555 	if (len == 0) {
556 		mutex_exit(&sp->lock);
557 		return (0);
558 	}
559 
560 	/*
561 	 * We're supposed to move the data out to userland, but
562 	 * that can suspend because of page faults etc., and meanwhile
563 	 * other parts of this driver want to update the PRI buffer ...
564 	 * we could hold the data buffer locked with a flag etc.,
565 	 * but that's still a lock ... a simpler mechanism - if not quite
566 	 * as performance efficient is to simply clone here the part of
567 	 * the buffer we care about and then the original can be released
568 	 * for further updates while the uiomove continues.
569 	 */
570 
571 	tmpbufp = kmem_alloc(len, KM_SLEEP);
572 	bcopy(((caddr_t)sp->ds_pri), tmpbufp, len);
573 	mutex_exit(&sp->lock);
574 
575 	retval = uiomove(tmpbufp, len, UIO_READ, uiop);
576 
577 	kmem_free(tmpbufp, len);
578 
579 	/*
580 	 * restore uio_offset after uiomove since the driver
581 	 * does not support the concept of position.
582 	 */
583 	uiop->uio_offset = off;
584 
585 	return (retval);
586 }
587 
588 
589 /*ARGSUSED*/
590 static int
ds_pri_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)591 ds_pri_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
592     int *rvalp)
593 {
594 	ds_pri_state_t *sp;
595 	int instance;
596 
597 	instance = getminor(dev);
598 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
599 		return (ENXIO);
600 
601 	switch (cmd) {
602 	case DSPRI_GETINFO: {
603 		struct dspri_info info;
604 
605 		if (!(mode & FREAD))
606 			return (EACCES);
607 
608 		/*
609 		 * We are not guaranteed that ddi_copyout(9F) will read
610 		 * atomically anything larger than a byte.  Therefore we
611 		 * must duplicate the size before copying it out to the user.
612 		 */
613 		mutex_enter(&sp->lock);
614 
615 loop:;
616 		if (sp->state & DS_PRI_HAS_PRI) {
617 			/* If we have a PRI simply return the info */
618 			info.size = sp->ds_pri_len;
619 			info.token = sp->gencount;
620 		} else
621 		if (!(sp->state & DS_PRI_HAS_SERVICE)) {
622 			/* If we have no service return a nil response */
623 			info.size = 0;
624 			info.token = 0;
625 		} else {
626 			request_pri(sp);
627 			/* wait for something & check again */
628 			if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
629 				mutex_exit(&sp->lock);
630 				return (EINTR);
631 			}
632 			goto loop;
633 		}
634 		DS_PRI_DBG("ds_pri_ioctl: DSPRI_GETINFO sz=0x%lx tok=0x%lx\n",
635 		    info.size, info.token);
636 		mutex_exit(&sp->lock);
637 
638 		if (ddi_copyout(&info, (void *)arg, sizeof (info), mode) != 0)
639 			return (EFAULT);
640 		break;
641 	}
642 
643 	case DSPRI_WAIT: {
644 		uint64_t gencount;
645 
646 		if (ddi_copyin((void *)arg, &gencount, sizeof (gencount),
647 		    mode) != 0)
648 			return (EFAULT);
649 
650 		mutex_enter(&sp->lock);
651 
652 		DS_PRI_DBG("ds_pri_ioctl: DSPRI_WAIT gen=0x%lx sp->gen=0x%lx\n",
653 		    gencount, sp->gencount);
654 
655 		while ((sp->state & DS_PRI_HAS_PRI) == 0 ||
656 		    gencount == sp->gencount) {
657 			if ((sp->state & DS_PRI_HAS_PRI) == 0)
658 				request_pri(sp);
659 			if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
660 				mutex_exit(&sp->lock);
661 				return (EINTR);
662 			}
663 		}
664 		mutex_exit(&sp->lock);
665 		break;
666 	}
667 
668 	default:
669 		return (ENOTTY);
670 	}
671 	return (0);
672 }
673 
674 
675 	/* assumes sp->lock is held when called */
676 static void
request_pri(ds_pri_state_t * sp)677 request_pri(ds_pri_state_t *sp)
678 {
679 	ds_pri_msg_t reqmsg;
680 
681 	ASSERT(MUTEX_HELD(&sp->lock));
682 
683 	/* If a request is already pending we're done */
684 	if (!(sp->state & DS_PRI_HAS_SERVICE))
685 		return;
686 	if (sp->state & DS_PRI_REQUESTED)
687 		return;
688 
689 	/* If we have an old PRI - remove it */
690 	if (sp->state & DS_PRI_HAS_PRI) {
691 		ASSERT(sp->ds_pri_len != 0);
692 		ASSERT(sp->ds_pri != NULL);
693 
694 		/* remove the old data if we have an outstanding request */
695 		kmem_free(sp->ds_pri, sp->ds_pri_len);
696 		sp->ds_pri_len = 0;
697 		sp->ds_pri = NULL;
698 		sp->state &= ~DS_PRI_HAS_PRI;
699 	} else {
700 		ASSERT(sp->ds_pri == NULL);
701 		ASSERT(sp->ds_pri_len == 0);
702 	}
703 
704 	reqmsg.hdr.seq_num = ++(sp->req_id);
705 	reqmsg.hdr.type = DS_PRI_REQUEST;
706 
707 	DS_PRI_DBG("request_pri: request id 0x%lx\n", sp->req_id);
708 
709 		/*
710 		 * Request consists of header only.
711 		 * We don't care about fail status for ds_send;
712 		 * if it does fail we will get an unregister callback
713 		 * from the DS framework and we handle the state change
714 		 * there.
715 		 */
716 	(void) ds_cap_send(sp->ds_pri_handle, &reqmsg, sizeof (reqmsg.hdr));
717 
718 	sp->state |= DS_PRI_REQUESTED;
719 	sp->last_req_id = sp->req_id;
720 }
721 
722 /*
723  * DS Callbacks
724  */
725 /*ARGSUSED*/
726 static void
ds_pri_reg_handler(ds_cb_arg_t arg,ds_ver_t * ver,ds_svc_hdl_t hdl)727 ds_pri_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
728 {
729 	dev_info_t *dip = arg;
730 	ds_pri_state_t *sp;
731 	int instance;
732 
733 	instance = ddi_get_instance(dip);
734 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
735 		return;
736 
737 	DS_PRI_DBG("ds_pri_reg_handler: registering handle 0x%lx for version "
738 	    "0x%x:0x%x\n", (uint64_t)hdl, ver->major, ver->minor);
739 
740 	/* When the domain service comes up automatically update the state */
741 	mutex_enter(&sp->lock);
742 
743 	ASSERT(sp->ds_pri_handle == DS_INVALID_HDL);
744 	sp->ds_pri_handle = hdl;
745 
746 	ASSERT(!(sp->state & DS_PRI_HAS_SERVICE));
747 	sp->state |= DS_PRI_HAS_SERVICE;
748 
749 	/*
750 	 * Cannot request a PRI here, because the reg handler cannot
751 	 * do a DS send operation - we take care of this later.
752 	 * Static hv pri data might be available.
753 	 */
754 
755 	/* Wake up anyone waiting in open() */
756 	cv_broadcast(&sp->cv);
757 
758 	mutex_exit(&sp->lock);
759 }
760 
761 
762 static void
ds_pri_unreg_handler(ds_cb_arg_t arg)763 ds_pri_unreg_handler(ds_cb_arg_t arg)
764 {
765 	dev_info_t *dip = arg;
766 	ds_pri_state_t *sp;
767 	int instance;
768 
769 	instance = ddi_get_instance(dip);
770 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
771 		return;
772 
773 	DS_PRI_DBG("ds_pri_unreg_handler: un-registering ds_pri service\n");
774 
775 	mutex_enter(&sp->lock);
776 
777 	/*
778 	 * Note that if the service goes offline, we don't
779 	 * free up the current PRI data at hand. It is assumed
780 	 * that PRI DS service will only push new update when
781 	 * it comes online. We mark the state to indicate no
782 	 * DS PRI service is available. The current PRI data if
783 	 * available is provided to the consumers.
784 	 */
785 	sp->ds_pri_handle = DS_INVALID_HDL;
786 	sp->state &= ~DS_PRI_HAS_SERVICE;
787 
788 	mutex_exit(&sp->lock);
789 }
790 
791 
792 static void
ds_pri_data_handler(ds_cb_arg_t arg,void * buf,size_t buflen)793 ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
794 {
795 	dev_info_t *dip = arg;
796 	ds_pri_state_t *sp;
797 	int instance;
798 	void *data;
799 	ds_pri_msg_t	*msgp;
800 	size_t	pri_size;
801 
802 	msgp = (ds_pri_msg_t *)buf;
803 
804 	/* make sure the header is at least valid */
805 	if (buflen < sizeof (msgp->hdr))
806 		return;
807 
808 	DS_PRI_DBG("ds_pri_data_handler: msg buf len 0x%lx : type 0x%lx, "
809 	    "seqn 0x%lx\n", buflen, msgp->hdr.type, msgp->hdr.seq_num);
810 
811 	instance = ddi_get_instance(dip);
812 	if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
813 		return;
814 
815 	mutex_enter(&sp->lock);
816 
817 	ASSERT(sp->state & DS_PRI_HAS_SERVICE);
818 
819 	switch (msgp->hdr.type) {
820 	case DS_PRI_DATA:	/* in response to a request from us */
821 		break;
822 	case DS_PRI_UPDATE:	/* aynch notification */
823 			/* our default response to this is to request the PRI */
824 		/* simply issue a request for the new PRI */
825 		request_pri(sp);
826 		goto done;
827 	default:	/* ignore garbage or unknown message types */
828 		goto done;
829 	}
830 
831 	/*
832 	 * If there is no pending PRI request, then we've received a
833 	 * bogus data message ... so ignore it.
834 	 */
835 
836 	if (!(sp->state & DS_PRI_REQUESTED)) {
837 		cmn_err(CE_WARN, "Received DS pri data without request");
838 		goto done;
839 	}
840 
841 	/* response to a request therefore old PRI must be gone */
842 	ASSERT(!(sp->state & DS_PRI_HAS_PRI));
843 	ASSERT(sp->ds_pri_len == 0);
844 	ASSERT(sp->ds_pri == NULL);
845 
846 	/* response seq_num should match our request seq_num */
847 	if (msgp->hdr.seq_num != sp->last_req_id) {
848 		cmn_err(CE_WARN, "Received DS pri data out of sequence with "
849 		    "request");
850 		goto done;
851 	}
852 
853 	pri_size = buflen - sizeof (msgp->hdr);
854 	if (pri_size == 0) {
855 		cmn_err(CE_WARN, "Received DS pri data of size 0");
856 		goto done;
857 	}
858 	data = kmem_alloc(pri_size, KM_SLEEP);
859 	sp->ds_pri = data;
860 	sp->ds_pri_len = pri_size;
861 	bcopy(msgp->data, data, sp->ds_pri_len);
862 	sp->state &= ~DS_PRI_REQUESTED;
863 	sp->state |= DS_PRI_HAS_PRI;
864 
865 	sp->gencount++;
866 	cv_broadcast(&sp->cv);
867 
868 done:;
869 	mutex_exit(&sp->lock);
870 }
871 
872 /*
873  * Routine to get static PRI data from the Hypervisor.
874  * If successful, this PRI data is the last known PRI
875  * data generated since the last poweron reset.
876  */
877 static uint64_t
ds_get_hv_pri(ds_pri_state_t * sp)878 ds_get_hv_pri(ds_pri_state_t *sp)
879 {
880 	uint64_t	status;
881 	uint64_t	pri_size;
882 	uint64_t	buf_size;
883 	uint64_t	buf_pa;
884 	caddr_t		buf_va = NULL;
885 	caddr_t		pri_data;
886 
887 	/*
888 	 * Get pri buffer size by calling hcall with buffer size 0.
889 	 */
890 	pri_size = 0LL;
891 	status = hv_mach_pri((uint64_t)0, &pri_size);
892 	if (status == H_ENOTSUPPORTED || status == H_ENOACCESS) {
893 		/*
894 		 * hv_mach_pri() is not supported on a guest domain.
895 		 * Unregister pboot API group to prevent failures.
896 		 */
897 		(void) hsvc_unregister(&pboot_hsvc);
898 		hsvc_pboot_available = B_FALSE;
899 		DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri service is not "
900 		    "available. errorno: 0x%lx\n", status);
901 		return (0);
902 	} else if (pri_size == 0) {
903 		return (1);
904 	} else {
905 		DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri pri size: 0x%lx\n",
906 		    pri_size);
907 	}
908 
909 	/*
910 	 * contig_mem_alloc requires size to be a power of 2.
911 	 * Increase size to next power of 2 if necessary.
912 	 */
913 	if (!ISP2(pri_size))
914 		buf_size = 1 << highbit(pri_size);
915 	DS_PRI_DBG("ds_get_hv_pri: buf_size = 0x%lx\n", buf_size);
916 
917 	buf_va = contig_mem_alloc(buf_size);
918 	if (buf_va == NULL)
919 		return (1);
920 
921 	buf_pa = va_to_pa(buf_va);
922 	DS_PRI_DBG("ds_get_hv_pri: buf_pa 0x%lx\n", buf_pa);
923 	status = hv_mach_pri(buf_pa, &pri_size);
924 	DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri status = 0x%lx\n", status);
925 
926 	if (status == H_EOK) {
927 		pri_data = kmem_alloc(pri_size, KM_SLEEP);
928 		sp->ds_pri = pri_data;
929 		sp->ds_pri_len = pri_size;
930 		bcopy(buf_va, pri_data, sp->ds_pri_len);
931 		sp->state |= DS_PRI_HAS_PRI;
932 		sp->gencount++;
933 	}
934 
935 	contig_mem_free(buf_va, buf_size);
936 
937 	return (status);
938 }
939