1ef884685Srb /*
2ef884685Srb * CDDL HEADER START
3ef884685Srb *
4ef884685Srb * The contents of this file are subject to the terms of the
5ef884685Srb * Common Development and Distribution License (the "License").
6ef884685Srb * You may not use this file except in compliance with the License.
7ef884685Srb *
8ef884685Srb * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9ef884685Srb * or http://www.opensolaris.org/os/licensing.
10ef884685Srb * See the License for the specific language governing permissions
11ef884685Srb * and limitations under the License.
12ef884685Srb *
13ef884685Srb * When distributing Covered Code, include this CDDL HEADER in each
14ef884685Srb * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15ef884685Srb * If applicable, add the following below this CDDL HEADER, with the
16ef884685Srb * fields enclosed by brackets "[]" replaced with your own identifying
17ef884685Srb * information: Portions Copyright [yyyy] [name of copyright owner]
18ef884685Srb *
19ef884685Srb * CDDL HEADER END
20ef884685Srb */
21ef884685Srb /*
227c18cbb1SSree Vemuri * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
23ef884685Srb */
24ef884685Srb
25ef884685Srb /*
26ef884685Srb * sun4v domain services PRI driver
27ef884685Srb */
28ef884685Srb
29ef884685Srb #include <sys/types.h>
30ef884685Srb #include <sys/file.h>
31ef884685Srb #include <sys/errno.h>
32ef884685Srb #include <sys/open.h>
33ef884685Srb #include <sys/cred.h>
34ef884685Srb #include <sys/uio.h>
35ef884685Srb #include <sys/stat.h>
36ef884685Srb #include <sys/ksynch.h>
37ef884685Srb #include <sys/modctl.h>
38ef884685Srb #include <sys/conf.h>
39ef884685Srb #include <sys/devops.h>
40ef884685Srb #include <sys/debug.h>
41ef884685Srb #include <sys/cmn_err.h>
42ef884685Srb #include <sys/ddi.h>
43ef884685Srb #include <sys/sunddi.h>
44ef884685Srb #include <sys/ds.h>
454df55fdeSJanie Lu #include <sys/hypervisor_api.h>
464df55fdeSJanie Lu #include <sys/machsystm.h>
474df55fdeSJanie Lu #include <sys/sysmacros.h>
484df55fdeSJanie Lu #include <sys/hsvc.h>
494df55fdeSJanie Lu #include <sys/bitmap.h>
50ef884685Srb #include <sys/ds_pri.h>
51ef884685Srb
52ef884685Srb static uint_t ds_pri_debug = 0;
53ef884685Srb #define DS_PRI_DBG if (ds_pri_debug) printf
54ef884685Srb
55ef884685Srb #define DS_PRI_NAME "ds_pri"
56ef884685Srb
57ef884685Srb #define TEST_HARNESS
58ef884685Srb #ifdef TEST_HARNESS
59ef884685Srb #define DS_PRI_MAX_PRI_SIZE (64 * 1024)
60ef884685Srb
61ef884685Srb #define DSIOC_TEST_REG 97
62ef884685Srb #define DSIOC_TEST_UNREG 98
63ef884685Srb #define DSIOC_TEST_DATA 99
64ef884685Srb
65ef884685Srb struct ds_pri_test_data {
66ef884685Srb size_t size;
67ef884685Srb void *data;
68ef884685Srb };
69ef884685Srb
70ef884685Srb struct ds_pri_test_data32 {
71ef884685Srb size32_t size;
72ef884685Srb caddr32_t data;
73ef884685Srb };
74ef884685Srb #endif /* TEST_HARNESS */
75ef884685Srb
76ef884685Srb typedef enum {
77ef884685Srb DS_PRI_REQUEST = 0,
78ef884685Srb DS_PRI_DATA = 1,
79ef884685Srb DS_PRI_UPDATE = 2
80ef884685Srb } ds_pri_msg_type_t;
81ef884685Srb
82ef884685Srb typedef struct {
83ef884685Srb struct {
84ef884685Srb uint64_t seq_num;
85ef884685Srb uint64_t type;
86ef884685Srb } hdr;
87ef884685Srb uint8_t data[1];
88ef884685Srb } ds_pri_msg_t;
89ef884685Srb
904df55fdeSJanie Lu /*
914df55fdeSJanie Lu * The following are bit field flags. No service implies no DS PRI and
924df55fdeSJanie Lu * no outstanding request.
934df55fdeSJanie Lu */
94ef884685Srb typedef enum {
95ef884685Srb DS_PRI_NO_SERVICE = 0x0,
96ef884685Srb DS_PRI_HAS_SERVICE = 0x1,
97ef884685Srb DS_PRI_REQUESTED = 0x2,
98ef884685Srb DS_PRI_HAS_PRI = 0x4
99ef884685Srb } ds_pri_flags_t;
100ef884685Srb
101ef884685Srb struct ds_pri_state {
102ef884685Srb dev_info_t *dip;
103ef884685Srb int instance;
104ef884685Srb
105ef884685Srb kmutex_t lock;
106ef884685Srb kcondvar_t cv;
107ef884685Srb
108ef884685Srb /* PRI/DS */
109ef884685Srb ds_pri_flags_t state;
110ef884685Srb uint64_t gencount;
111ef884685Srb ds_svc_hdl_t ds_pri_handle;
112ef884685Srb void *ds_pri;
113ef884685Srb size_t ds_pri_len;
114ef884685Srb uint64_t req_id;
115ef884685Srb uint64_t last_req_id;
1160d63ce2bSvenki int num_opens;
117ef884685Srb };
118ef884685Srb
119ef884685Srb typedef struct ds_pri_state ds_pri_state_t;
120ef884685Srb
121ef884685Srb static void *ds_pri_statep;
122ef884685Srb
123ef884685Srb static void request_pri(ds_pri_state_t *sp);
1244df55fdeSJanie Lu static uint64_t ds_get_hv_pri(ds_pri_state_t *sp);
125ef884685Srb
126ef884685Srb static int ds_pri_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
127ef884685Srb static int ds_pri_attach(dev_info_t *, ddi_attach_cmd_t);
128ef884685Srb static int ds_pri_detach(dev_info_t *, ddi_detach_cmd_t);
129ef884685Srb static int ds_pri_open(dev_t *, int, int, cred_t *);
130ef884685Srb static int ds_pri_close(dev_t, int, int, cred_t *);
131ef884685Srb static int ds_pri_read(dev_t, struct uio *, cred_t *);
132ef884685Srb static int ds_pri_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
133ef884685Srb
134ef884685Srb /*
135ef884685Srb * DS Callbacks
136ef884685Srb */
137ef884685Srb static void ds_pri_reg_handler(ds_cb_arg_t, ds_ver_t *, ds_svc_hdl_t);
138ef884685Srb static void ds_pri_unreg_handler(ds_cb_arg_t arg);
139ef884685Srb static void ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);
140ef884685Srb
141ef884685Srb /*
142ef884685Srb * PRI DS capability registration
143ef884685Srb */
144ef884685Srb
145ef884685Srb static ds_ver_t ds_pri_ver_1_0 = { 1, 0 };
146ef884685Srb
147ef884685Srb static ds_capability_t ds_pri_cap = {
148ef884685Srb "pri",
149ef884685Srb &ds_pri_ver_1_0,
150ef884685Srb 1
151ef884685Srb };
152ef884685Srb
153ef884685Srb /*
154ef884685Srb * PRI DS Client callback vector
155ef884685Srb */
156ef884685Srb static ds_clnt_ops_t ds_pri_ops = {
157ef884685Srb ds_pri_reg_handler, /* ds_reg_cb */
158ef884685Srb ds_pri_unreg_handler, /* ds_unreg_cb */
159ef884685Srb ds_pri_data_handler, /* ds_data_cb */
160ef884685Srb NULL /* cb_arg */
161ef884685Srb };
162ef884685Srb
163ef884685Srb /*
164ef884685Srb * DS PRI driver Ops Vector
165ef884685Srb */
166ef884685Srb static struct cb_ops ds_pri_cb_ops = {
167ef884685Srb ds_pri_open, /* cb_open */
168ef884685Srb ds_pri_close, /* cb_close */
169ef884685Srb nodev, /* cb_strategy */
170ef884685Srb nodev, /* cb_print */
171ef884685Srb nodev, /* cb_dump */
172ef884685Srb ds_pri_read, /* cb_read */
173ef884685Srb nodev, /* cb_write */
174ef884685Srb ds_pri_ioctl, /* cb_ioctl */
175ef884685Srb nodev, /* cb_devmap */
176ef884685Srb nodev, /* cb_mmap */
177ef884685Srb nodev, /* cb_segmap */
178ef884685Srb nochpoll, /* cb_chpoll */
179ef884685Srb ddi_prop_op, /* cb_prop_op */
180ef884685Srb (struct streamtab *)NULL, /* cb_str */
181ef884685Srb D_MP | D_64BIT, /* cb_flag */
182ef884685Srb CB_REV, /* cb_rev */
183ef884685Srb nodev, /* cb_aread */
184ef884685Srb nodev /* cb_awrite */
185ef884685Srb };
186ef884685Srb
187ef884685Srb static struct dev_ops ds_pri_dev_ops = {
188ef884685Srb DEVO_REV, /* devo_rev */
189ef884685Srb 0, /* devo_refcnt */
190ef884685Srb ds_pri_getinfo, /* devo_getinfo */
191ef884685Srb nulldev, /* devo_identify */
192ef884685Srb nulldev, /* devo_probe */
193ef884685Srb ds_pri_attach, /* devo_attach */
194ef884685Srb ds_pri_detach, /* devo_detach */
195ef884685Srb nodev, /* devo_reset */
196ef884685Srb &ds_pri_cb_ops, /* devo_cb_ops */
197ef884685Srb (struct bus_ops *)NULL, /* devo_bus_ops */
19819397407SSherry Moore nulldev, /* devo_power */
19919397407SSherry Moore ddi_quiesce_not_needed, /* devo_quiesce */
200ef884685Srb };
201ef884685Srb
202ef884685Srb static struct modldrv modldrv = {
203ef884685Srb &mod_driverops,
20419397407SSherry Moore "Domain Services PRI Driver",
205ef884685Srb &ds_pri_dev_ops
206ef884685Srb };
207ef884685Srb
208ef884685Srb static struct modlinkage modlinkage = {
209ef884685Srb MODREV_1,
210ef884685Srb (void *)&modldrv,
211ef884685Srb NULL
212ef884685Srb };
213ef884685Srb
2144df55fdeSJanie Lu static boolean_t hsvc_pboot_available = B_FALSE;
2154df55fdeSJanie Lu static hsvc_info_t pboot_hsvc = {
2164df55fdeSJanie Lu HSVC_REV_1, NULL, HSVC_GROUP_PBOOT, 1, 0, NULL
2174df55fdeSJanie Lu };
218ef884685Srb
219ef884685Srb int
_init(void)220ef884685Srb _init(void)
221ef884685Srb {
222ef884685Srb int retval;
2234df55fdeSJanie Lu uint64_t hsvc_pboot_minor;
2244df55fdeSJanie Lu uint64_t status;
2254df55fdeSJanie Lu
2264df55fdeSJanie Lu status = hsvc_register(&pboot_hsvc, &hsvc_pboot_minor);
2274df55fdeSJanie Lu if (status == H_EOK) {
2284df55fdeSJanie Lu hsvc_pboot_available = B_TRUE;
2294df55fdeSJanie Lu } else {
2304df55fdeSJanie Lu DS_PRI_DBG("hypervisor services not negotiated "
2314df55fdeSJanie Lu "for group number: 0x%lx errorno: 0x%lx\n",
2324df55fdeSJanie Lu pboot_hsvc.hsvc_group, status);
2334df55fdeSJanie Lu }
234ef884685Srb
235ef884685Srb retval = ddi_soft_state_init(&ds_pri_statep,
236ef884685Srb sizeof (ds_pri_state_t), 0);
237ef884685Srb if (retval != 0)
238ef884685Srb return (retval);
239ef884685Srb
240ef884685Srb retval = mod_install(&modlinkage);
241ef884685Srb if (retval != 0) {
242ef884685Srb ddi_soft_state_fini(&ds_pri_statep);
243ef884685Srb return (retval);
244ef884685Srb }
245ef884685Srb
246ef884685Srb return (retval);
247ef884685Srb }
248ef884685Srb
249ef884685Srb
250ef884685Srb int
_info(struct modinfo * modinfop)251ef884685Srb _info(struct modinfo *modinfop)
252ef884685Srb {
253ef884685Srb return (mod_info(&modlinkage, modinfop));
254ef884685Srb }
255ef884685Srb
256ef884685Srb
257ef884685Srb int
_fini(void)258ef884685Srb _fini(void)
259ef884685Srb {
260ef884685Srb int retval;
261ef884685Srb
262ef884685Srb if ((retval = mod_remove(&modlinkage)) != 0)
263ef884685Srb return (retval);
264ef884685Srb
265ef884685Srb ddi_soft_state_fini(&ds_pri_statep);
266ef884685Srb
2677c18cbb1SSree Vemuri if (hsvc_pboot_available)
2687c18cbb1SSree Vemuri (void) hsvc_unregister(&pboot_hsvc);
2694df55fdeSJanie Lu
270ef884685Srb return (retval);
271ef884685Srb }
272ef884685Srb
273ef884685Srb
274ef884685Srb /*ARGSUSED*/
275ef884685Srb static int
ds_pri_getinfo(dev_info_t * dip,ddi_info_cmd_t cmd,void * arg,void ** resultp)276ef884685Srb ds_pri_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
277ef884685Srb {
278ef884685Srb ds_pri_state_t *sp;
279ef884685Srb int retval = DDI_FAILURE;
280ef884685Srb
281ef884685Srb ASSERT(resultp != NULL);
282ef884685Srb
283ef884685Srb switch (cmd) {
284ef884685Srb case DDI_INFO_DEVT2DEVINFO:
285ef884685Srb sp = ddi_get_soft_state(ds_pri_statep, getminor((dev_t)arg));
286ef884685Srb if (sp != NULL) {
287ef884685Srb *resultp = sp->dip;
288ef884685Srb retval = DDI_SUCCESS;
289ef884685Srb } else
290ef884685Srb *resultp = NULL;
291ef884685Srb break;
292ef884685Srb
293ef884685Srb case DDI_INFO_DEVT2INSTANCE:
294ef884685Srb *resultp = (void *)(uintptr_t)getminor((dev_t)arg);
295ef884685Srb retval = DDI_SUCCESS;
296ef884685Srb break;
297ef884685Srb
298ef884685Srb default:
299ef884685Srb break;
300ef884685Srb }
301ef884685Srb
302ef884685Srb return (retval);
303ef884685Srb }
304ef884685Srb
305ef884685Srb
306ef884685Srb static int
ds_pri_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)307ef884685Srb ds_pri_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
308ef884685Srb {
309ef884685Srb int instance;
310ef884685Srb ds_pri_state_t *sp;
311ef884685Srb int rv;
3124df55fdeSJanie Lu uint64_t status;
313ef884685Srb
314ef884685Srb switch (cmd) {
315ef884685Srb case DDI_ATTACH:
316ef884685Srb break;
317ef884685Srb
318ef884685Srb case DDI_RESUME:
319ef884685Srb return (DDI_SUCCESS);
320ef884685Srb
321ef884685Srb default:
322ef884685Srb return (DDI_FAILURE);
323ef884685Srb }
324ef884685Srb
325ef884685Srb instance = ddi_get_instance(dip);
326ef884685Srb
327ef884685Srb if (ddi_soft_state_zalloc(ds_pri_statep, instance) !=
328ef884685Srb DDI_SUCCESS) {
329ef884685Srb cmn_err(CE_WARN, "%s@%d: Unable to allocate state",
330ef884685Srb DS_PRI_NAME, instance);
331ef884685Srb return (DDI_FAILURE);
332ef884685Srb }
333ef884685Srb sp = ddi_get_soft_state(ds_pri_statep, instance);
334ef884685Srb
335ef884685Srb mutex_init(&sp->lock, NULL, MUTEX_DEFAULT, NULL);
336ef884685Srb cv_init(&sp->cv, NULL, CV_DEFAULT, NULL);
337ef884685Srb
338ef884685Srb if (ddi_create_minor_node(dip, DS_PRI_NAME, S_IFCHR, instance,
3393597045eSnarayan DDI_PSEUDO, 0) != DDI_SUCCESS) {
340ef884685Srb cmn_err(CE_WARN, "%s@%d: Unable to create minor node",
341ef884685Srb DS_PRI_NAME, instance);
342ef884685Srb goto fail;
343ef884685Srb }
344ef884685Srb
345ef884685Srb if (ds_pri_ops.cb_arg != NULL)
346ef884685Srb goto fail;
347ef884685Srb ds_pri_ops.cb_arg = dip;
348ef884685Srb
349ef884685Srb sp->state = DS_PRI_NO_SERVICE;
350ef884685Srb
351ef884685Srb /* Until the service registers the handle is invalid */
352ef884685Srb sp->ds_pri_handle = DS_INVALID_HDL;
353ef884685Srb
354ef884685Srb sp->ds_pri = NULL;
355ef884685Srb sp->ds_pri_len = 0;
356ef884685Srb sp->req_id = 0;
3570d63ce2bSvenki sp->num_opens = 0;
358ef884685Srb
3594df55fdeSJanie Lu /*
3604df55fdeSJanie Lu * See if we can get the static hv pri data. Static pri data
3614df55fdeSJanie Lu * is only available for privileged domains.
3624df55fdeSJanie Lu */
3637c18cbb1SSree Vemuri if (hsvc_pboot_available) {
3644df55fdeSJanie Lu if ((status = ds_get_hv_pri(sp)) != 0) {
3654df55fdeSJanie Lu cmn_err(CE_NOTE, "ds_get_hv_pri failed: 0x%lx", status);
3664df55fdeSJanie Lu }
3674df55fdeSJanie Lu }
3684df55fdeSJanie Lu
369ef884685Srb if ((rv = ds_cap_init(&ds_pri_cap, &ds_pri_ops)) != 0) {
370ef884685Srb cmn_err(CE_NOTE, "ds_cap_init failed: %d", rv);
371ef884685Srb goto fail;
372ef884685Srb }
373ef884685Srb
374ef884685Srb ddi_report_dev(dip);
375ef884685Srb
376ef884685Srb return (DDI_SUCCESS);
377ef884685Srb
378ef884685Srb fail:
3794df55fdeSJanie Lu if (sp->ds_pri)
3804df55fdeSJanie Lu kmem_free(sp->ds_pri, sp->ds_pri_len);
381ef884685Srb ddi_remove_minor_node(dip, NULL);
382ef884685Srb cv_destroy(&sp->cv);
383ef884685Srb mutex_destroy(&sp->lock);
384ef884685Srb ddi_soft_state_free(ds_pri_statep, instance);
385ef884685Srb return (DDI_FAILURE);
386ef884685Srb
387ef884685Srb }
388ef884685Srb
389ef884685Srb
390ef884685Srb /*ARGSUSED*/
391ef884685Srb static int
ds_pri_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)392ef884685Srb ds_pri_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
393ef884685Srb {
394ef884685Srb ds_pri_state_t *sp;
395ef884685Srb int instance;
396ef884685Srb int rv;
397ef884685Srb
398ef884685Srb instance = ddi_get_instance(dip);
399ef884685Srb sp = ddi_get_soft_state(ds_pri_statep, instance);
400ef884685Srb
401ef884685Srb switch (cmd) {
402ef884685Srb case DDI_DETACH:
403ef884685Srb break;
404ef884685Srb
405ef884685Srb case DDI_SUSPEND:
406ef884685Srb return (DDI_SUCCESS);
407ef884685Srb
408ef884685Srb default:
409ef884685Srb return (DDI_FAILURE);
410ef884685Srb }
411ef884685Srb
412ef884685Srb /* This really shouldn't fail - but check anyway */
413ef884685Srb if ((rv = ds_cap_fini(&ds_pri_cap)) != 0) {
414ef884685Srb cmn_err(CE_WARN, "ds_cap_fini failed: %d", rv);
415ef884685Srb }
416ef884685Srb
417ef884685Srb if (sp != NULL && sp->ds_pri_len != 0)
418ef884685Srb kmem_free(sp->ds_pri, sp->ds_pri_len);
419ef884685Srb
4203597045eSnarayan ds_pri_ops.cb_arg = NULL;
4213597045eSnarayan
422ef884685Srb ddi_remove_minor_node(dip, NULL);
423ef884685Srb cv_destroy(&sp->cv);
424ef884685Srb mutex_destroy(&sp->lock);
425ef884685Srb ddi_soft_state_free(ds_pri_statep, instance);
426ef884685Srb
427ef884685Srb return (DDI_SUCCESS);
428ef884685Srb }
429ef884685Srb
430ef884685Srb
431ef884685Srb /*ARGSUSED*/
432ef884685Srb static int
ds_pri_open(dev_t * devp,int flag,int otyp,cred_t * credp)433ef884685Srb ds_pri_open(dev_t *devp, int flag, int otyp, cred_t *credp)
434ef884685Srb {
435ef884685Srb ds_pri_state_t *sp;
436ef884685Srb int instance;
437ef884685Srb
438ef884685Srb if (otyp != OTYP_CHR)
439ef884685Srb return (EINVAL);
440ef884685Srb
441ef884685Srb instance = getminor(*devp);
442ef884685Srb sp = ddi_get_soft_state(ds_pri_statep, instance);
443ef884685Srb if (sp == NULL)
444ef884685Srb return (ENXIO);
445ef884685Srb
4460d63ce2bSvenki mutex_enter(&sp->lock);
4470d63ce2bSvenki
4480d63ce2bSvenki /*
4494df55fdeSJanie Lu * Proceed if we have PRI data (possibly obtained from
4504df55fdeSJanie Lu * static HV PRI or last pushed DS PRI data update).
4514df55fdeSJanie Lu * If no PRI data and we have no DS PRI service then this
4524df55fdeSJanie Lu * means that PRI DS has never called the registration callback.
453e82e447aSkellena * A while loop is necessary as we might have been woken up
454e82e447aSkellena * prematurely, e.g., due to a debugger or "pstack" etc.
4550d63ce2bSvenki * Wait here and the callback will signal us when it has completed
4560d63ce2bSvenki * its work.
4570d63ce2bSvenki */
4584df55fdeSJanie Lu if (!(sp->state & DS_PRI_HAS_PRI)) {
4594df55fdeSJanie Lu while (!(sp->state & DS_PRI_HAS_SERVICE)) {
4604df55fdeSJanie Lu if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
4614df55fdeSJanie Lu mutex_exit(&sp->lock);
4624df55fdeSJanie Lu return (EINTR);
4634df55fdeSJanie Lu }
4640d63ce2bSvenki }
4650d63ce2bSvenki }
4660d63ce2bSvenki
4670d63ce2bSvenki sp->num_opens++;
4680d63ce2bSvenki mutex_exit(&sp->lock);
4690d63ce2bSvenki
470ef884685Srb DS_PRI_DBG("ds_pri_open: state = 0x%x\n", sp->state);
471ef884685Srb
472ef884685Srb return (0);
473ef884685Srb }
474ef884685Srb
475ef884685Srb
476ef884685Srb /*ARGSUSED*/
477ef884685Srb static int
ds_pri_close(dev_t dev,int flag,int otyp,cred_t * credp)478ef884685Srb ds_pri_close(dev_t dev, int flag, int otyp, cred_t *credp)
479ef884685Srb {
480ef884685Srb int instance;
4810d63ce2bSvenki ds_pri_state_t *sp;
482ef884685Srb
483ef884685Srb if (otyp != OTYP_CHR)
484ef884685Srb return (EINVAL);
485ef884685Srb
486ef884685Srb DS_PRI_DBG("ds_pri_close\n");
487ef884685Srb
488ef884685Srb instance = getminor(dev);
4890d63ce2bSvenki if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
490ef884685Srb return (ENXIO);
491ef884685Srb
4920d63ce2bSvenki mutex_enter(&sp->lock);
4930d63ce2bSvenki if (!(sp->state & DS_PRI_HAS_SERVICE)) {
4940d63ce2bSvenki mutex_exit(&sp->lock);
4950d63ce2bSvenki return (0);
4960d63ce2bSvenki }
4970d63ce2bSvenki
4980d63ce2bSvenki if (--sp->num_opens > 0) {
4990d63ce2bSvenki mutex_exit(&sp->lock);
5000d63ce2bSvenki return (0);
5010d63ce2bSvenki }
5020d63ce2bSvenki
5030d63ce2bSvenki sp->state &= ~DS_PRI_REQUESTED;
5040d63ce2bSvenki mutex_exit(&sp->lock);
505ef884685Srb return (0);
506ef884685Srb }
507ef884685Srb
508ef884685Srb
509ef884685Srb /*ARGSUSED*/
510ef884685Srb static int
ds_pri_read(dev_t dev,struct uio * uiop,cred_t * credp)511ef884685Srb ds_pri_read(dev_t dev, struct uio *uiop, cred_t *credp)
512ef884685Srb {
513ef884685Srb ds_pri_state_t *sp;
514ef884685Srb int instance;
515ef884685Srb size_t len;
516ef884685Srb int retval;
517ef884685Srb caddr_t tmpbufp;
5189b69f4d8SSree Vemuri offset_t off = uiop->uio_offset;
519ef884685Srb
520ef884685Srb instance = getminor(dev);
521ef884685Srb if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
522ef884685Srb return (ENXIO);
523ef884685Srb
524ef884685Srb len = uiop->uio_resid;
525ef884685Srb
526ef884685Srb if (len == 0)
527ef884685Srb return (0);
528ef884685Srb
529ef884685Srb mutex_enter(&sp->lock);
530ef884685Srb
531ef884685Srb DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);
532ef884685Srb
533ef884685Srb /* block or bail if there is no current PRI */
534ef884685Srb if (!(sp->state & DS_PRI_HAS_PRI)) {
535ef884685Srb DS_PRI_DBG("ds_pri_read: no PRI held\n");
536ef884685Srb
537ef884685Srb if (uiop->uio_fmode & (FNDELAY | FNONBLOCK)) {
538ef884685Srb mutex_exit(&sp->lock);
539ef884685Srb return (EAGAIN);
540ef884685Srb }
541ef884685Srb
542ef884685Srb while (!(sp->state & DS_PRI_HAS_PRI)) {
543ef884685Srb DS_PRI_DBG("ds_pri_read: state = 0x%x\n", sp->state);
544ef884685Srb request_pri(sp);
545ef884685Srb if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
546ef884685Srb mutex_exit(&sp->lock);
547ef884685Srb return (EINTR);
548ef884685Srb }
549ef884685Srb }
550ef884685Srb }
551ef884685Srb
5529b69f4d8SSree Vemuri if (len > sp->ds_pri_len)
5539b69f4d8SSree Vemuri len = sp->ds_pri_len;
554ef884685Srb
555ef884685Srb if (len == 0) {
556ef884685Srb mutex_exit(&sp->lock);
557ef884685Srb return (0);
558ef884685Srb }
559ef884685Srb
560ef884685Srb /*
561ef884685Srb * We're supposed to move the data out to userland, but
562ef884685Srb * that can suspend because of page faults etc., and meanwhile
563ef884685Srb * other parts of this driver want to update the PRI buffer ...
564ef884685Srb * we could hold the data buffer locked with a flag etc.,
565ef884685Srb * but that's still a lock ... a simpler mechanism - if not quite
566ef884685Srb * as performance efficient is to simply clone here the part of
567ef884685Srb * the buffer we care about and then the original can be released
568ef884685Srb * for further updates while the uiomove continues.
569ef884685Srb */
570ef884685Srb
571ef884685Srb tmpbufp = kmem_alloc(len, KM_SLEEP);
5729b69f4d8SSree Vemuri bcopy(((caddr_t)sp->ds_pri), tmpbufp, len);
573ef884685Srb mutex_exit(&sp->lock);
574ef884685Srb
575ef884685Srb retval = uiomove(tmpbufp, len, UIO_READ, uiop);
576ef884685Srb
577ef884685Srb kmem_free(tmpbufp, len);
578ef884685Srb
5799b69f4d8SSree Vemuri /*
5809b69f4d8SSree Vemuri * restore uio_offset after uiomove since the driver
5819b69f4d8SSree Vemuri * does not support the concept of position.
5829b69f4d8SSree Vemuri */
5839b69f4d8SSree Vemuri uiop->uio_offset = off;
5849b69f4d8SSree Vemuri
585ef884685Srb return (retval);
586ef884685Srb }
587ef884685Srb
588ef884685Srb
589ef884685Srb /*ARGSUSED*/
590ef884685Srb static int
ds_pri_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)591ef884685Srb ds_pri_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
592ef884685Srb int *rvalp)
593ef884685Srb {
594ef884685Srb ds_pri_state_t *sp;
595ef884685Srb int instance;
596ef884685Srb
597ef884685Srb instance = getminor(dev);
598ef884685Srb if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
599ef884685Srb return (ENXIO);
600ef884685Srb
601ef884685Srb switch (cmd) {
602ef884685Srb case DSPRI_GETINFO: {
603ef884685Srb struct dspri_info info;
604ef884685Srb
605ef884685Srb if (!(mode & FREAD))
606ef884685Srb return (EACCES);
607ef884685Srb
608ef884685Srb /*
609ef884685Srb * We are not guaranteed that ddi_copyout(9F) will read
610ef884685Srb * atomically anything larger than a byte. Therefore we
611ef884685Srb * must duplicate the size before copying it out to the user.
612ef884685Srb */
613ef884685Srb mutex_enter(&sp->lock);
614ef884685Srb
615ef884685Srb loop:;
616ef884685Srb if (sp->state & DS_PRI_HAS_PRI) {
617ef884685Srb /* If we have a PRI simply return the info */
618ef884685Srb info.size = sp->ds_pri_len;
619ef884685Srb info.token = sp->gencount;
620ef884685Srb } else
621ef884685Srb if (!(sp->state & DS_PRI_HAS_SERVICE)) {
622ef884685Srb /* If we have no service return a nil response */
623ef884685Srb info.size = 0;
624ef884685Srb info.token = 0;
625ef884685Srb } else {
626ef884685Srb request_pri(sp);
627ef884685Srb /* wait for something & check again */
628ef884685Srb if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
629ef884685Srb mutex_exit(&sp->lock);
630ef884685Srb return (EINTR);
631ef884685Srb }
632ef884685Srb goto loop;
633ef884685Srb }
634ef884685Srb DS_PRI_DBG("ds_pri_ioctl: DSPRI_GETINFO sz=0x%lx tok=0x%lx\n",
6353597045eSnarayan info.size, info.token);
636ef884685Srb mutex_exit(&sp->lock);
637ef884685Srb
638ef884685Srb if (ddi_copyout(&info, (void *)arg, sizeof (info), mode) != 0)
639ef884685Srb return (EFAULT);
640ef884685Srb break;
641ef884685Srb }
642ef884685Srb
643ef884685Srb case DSPRI_WAIT: {
644ef884685Srb uint64_t gencount;
645ef884685Srb
646ef884685Srb if (ddi_copyin((void *)arg, &gencount, sizeof (gencount),
647ef884685Srb mode) != 0)
648ef884685Srb return (EFAULT);
649ef884685Srb
650ef884685Srb mutex_enter(&sp->lock);
651ef884685Srb
652ef884685Srb DS_PRI_DBG("ds_pri_ioctl: DSPRI_WAIT gen=0x%lx sp->gen=0x%lx\n",
6533597045eSnarayan gencount, sp->gencount);
654ef884685Srb
655ef884685Srb while ((sp->state & DS_PRI_HAS_PRI) == 0 ||
6563597045eSnarayan gencount == sp->gencount) {
657e82e447aSkellena if ((sp->state & DS_PRI_HAS_PRI) == 0)
658e82e447aSkellena request_pri(sp);
659ef884685Srb if (cv_wait_sig(&sp->cv, &sp->lock) == 0) {
660ef884685Srb mutex_exit(&sp->lock);
661ef884685Srb return (EINTR);
662ef884685Srb }
663ef884685Srb }
664ef884685Srb mutex_exit(&sp->lock);
665ef884685Srb break;
666ef884685Srb }
667ef884685Srb
668ef884685Srb default:
669ef884685Srb return (ENOTTY);
670ef884685Srb }
671ef884685Srb return (0);
672ef884685Srb }
673ef884685Srb
674ef884685Srb
675ef884685Srb /* assumes sp->lock is held when called */
676ef884685Srb static void
request_pri(ds_pri_state_t * sp)677ef884685Srb request_pri(ds_pri_state_t *sp)
678ef884685Srb {
679ef884685Srb ds_pri_msg_t reqmsg;
680ef884685Srb
681ef884685Srb ASSERT(MUTEX_HELD(&sp->lock));
682ef884685Srb
683ef884685Srb /* If a request is already pending we're done */
684ef884685Srb if (!(sp->state & DS_PRI_HAS_SERVICE))
685ef884685Srb return;
686ef884685Srb if (sp->state & DS_PRI_REQUESTED)
687ef884685Srb return;
688ef884685Srb
689ef884685Srb /* If we have an old PRI - remove it */
690ef884685Srb if (sp->state & DS_PRI_HAS_PRI) {
691ef884685Srb ASSERT(sp->ds_pri_len != 0);
692ef884685Srb ASSERT(sp->ds_pri != NULL);
693ef884685Srb
694ef884685Srb /* remove the old data if we have an outstanding request */
695ef884685Srb kmem_free(sp->ds_pri, sp->ds_pri_len);
696ef884685Srb sp->ds_pri_len = 0;
697ef884685Srb sp->ds_pri = NULL;
698ef884685Srb sp->state &= ~DS_PRI_HAS_PRI;
699ef884685Srb } else {
700ef884685Srb ASSERT(sp->ds_pri == NULL);
701ef884685Srb ASSERT(sp->ds_pri_len == 0);
702ef884685Srb }
703ef884685Srb
704ef884685Srb reqmsg.hdr.seq_num = ++(sp->req_id);
705ef884685Srb reqmsg.hdr.type = DS_PRI_REQUEST;
706ef884685Srb
707ef884685Srb DS_PRI_DBG("request_pri: request id 0x%lx\n", sp->req_id);
708ef884685Srb
709ef884685Srb /*
710ef884685Srb * Request consists of header only.
711ef884685Srb * We don't care about fail status for ds_send;
712ef884685Srb * if it does fail we will get an unregister callback
713ef884685Srb * from the DS framework and we handle the state change
714ef884685Srb * there.
715ef884685Srb */
716ef884685Srb (void) ds_cap_send(sp->ds_pri_handle, &reqmsg, sizeof (reqmsg.hdr));
717ef884685Srb
718ef884685Srb sp->state |= DS_PRI_REQUESTED;
719ef884685Srb sp->last_req_id = sp->req_id;
720ef884685Srb }
721ef884685Srb
722ef884685Srb /*
723ef884685Srb * DS Callbacks
724ef884685Srb */
725ef884685Srb /*ARGSUSED*/
726ef884685Srb static void
ds_pri_reg_handler(ds_cb_arg_t arg,ds_ver_t * ver,ds_svc_hdl_t hdl)727ef884685Srb ds_pri_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
728ef884685Srb {
729ef884685Srb dev_info_t *dip = arg;
730ef884685Srb ds_pri_state_t *sp;
731ef884685Srb int instance;
732ef884685Srb
733ef884685Srb instance = ddi_get_instance(dip);
734ef884685Srb if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
735ef884685Srb return;
736ef884685Srb
737ef884685Srb DS_PRI_DBG("ds_pri_reg_handler: registering handle 0x%lx for version "
7383597045eSnarayan "0x%x:0x%x\n", (uint64_t)hdl, ver->major, ver->minor);
739ef884685Srb
7404df55fdeSJanie Lu /* When the domain service comes up automatically update the state */
741ef884685Srb mutex_enter(&sp->lock);
742ef884685Srb
743ef884685Srb ASSERT(sp->ds_pri_handle == DS_INVALID_HDL);
744ef884685Srb sp->ds_pri_handle = hdl;
745ef884685Srb
7464df55fdeSJanie Lu ASSERT(!(sp->state & DS_PRI_HAS_SERVICE));
747ef884685Srb sp->state |= DS_PRI_HAS_SERVICE;
748ef884685Srb
7490d63ce2bSvenki /*
7500d63ce2bSvenki * Cannot request a PRI here, because the reg handler cannot
7510d63ce2bSvenki * do a DS send operation - we take care of this later.
7524df55fdeSJanie Lu * Static hv pri data might be available.
7530d63ce2bSvenki */
7540d63ce2bSvenki
7550d63ce2bSvenki /* Wake up anyone waiting in open() */
7560d63ce2bSvenki cv_broadcast(&sp->cv);
7570d63ce2bSvenki
758ef884685Srb mutex_exit(&sp->lock);
759ef884685Srb }
760ef884685Srb
761ef884685Srb
762ef884685Srb static void
ds_pri_unreg_handler(ds_cb_arg_t arg)763ef884685Srb ds_pri_unreg_handler(ds_cb_arg_t arg)
764ef884685Srb {
765ef884685Srb dev_info_t *dip = arg;
766ef884685Srb ds_pri_state_t *sp;
767ef884685Srb int instance;
768ef884685Srb
769ef884685Srb instance = ddi_get_instance(dip);
770ef884685Srb if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
771ef884685Srb return;
772ef884685Srb
773ef884685Srb DS_PRI_DBG("ds_pri_unreg_handler: un-registering ds_pri service\n");
774ef884685Srb
775ef884685Srb mutex_enter(&sp->lock);
776ef884685Srb
7774df55fdeSJanie Lu /*
7784df55fdeSJanie Lu * Note that if the service goes offline, we don't
7794df55fdeSJanie Lu * free up the current PRI data at hand. It is assumed
7804df55fdeSJanie Lu * that PRI DS service will only push new update when
7814df55fdeSJanie Lu * it comes online. We mark the state to indicate no
7824df55fdeSJanie Lu * DS PRI service is available. The current PRI data if
7834df55fdeSJanie Lu * available is provided to the consumers.
7844df55fdeSJanie Lu */
785ef884685Srb sp->ds_pri_handle = DS_INVALID_HDL;
7864df55fdeSJanie Lu sp->state &= ~DS_PRI_HAS_SERVICE;
787ef884685Srb
788ef884685Srb mutex_exit(&sp->lock);
789ef884685Srb }
790ef884685Srb
791ef884685Srb
792ef884685Srb static void
ds_pri_data_handler(ds_cb_arg_t arg,void * buf,size_t buflen)793ef884685Srb ds_pri_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
794ef884685Srb {
795ef884685Srb dev_info_t *dip = arg;
796ef884685Srb ds_pri_state_t *sp;
797ef884685Srb int instance;
798ef884685Srb void *data;
799ef884685Srb ds_pri_msg_t *msgp;
800ef884685Srb size_t pri_size;
801ef884685Srb
802ef884685Srb msgp = (ds_pri_msg_t *)buf;
803ef884685Srb
804ef884685Srb /* make sure the header is at least valid */
805ef884685Srb if (buflen < sizeof (msgp->hdr))
806ef884685Srb return;
807ef884685Srb
808ef884685Srb DS_PRI_DBG("ds_pri_data_handler: msg buf len 0x%lx : type 0x%lx, "
8093597045eSnarayan "seqn 0x%lx\n", buflen, msgp->hdr.type, msgp->hdr.seq_num);
810ef884685Srb
811ef884685Srb instance = ddi_get_instance(dip);
812ef884685Srb if ((sp = ddi_get_soft_state(ds_pri_statep, instance)) == NULL)
813ef884685Srb return;
814ef884685Srb
815ef884685Srb mutex_enter(&sp->lock);
816ef884685Srb
817ef884685Srb ASSERT(sp->state & DS_PRI_HAS_SERVICE);
818ef884685Srb
819ef884685Srb switch (msgp->hdr.type) {
820ef884685Srb case DS_PRI_DATA: /* in response to a request from us */
821ef884685Srb break;
822ef884685Srb case DS_PRI_UPDATE: /* aynch notification */
823ef884685Srb /* our default response to this is to request the PRI */
824ef884685Srb /* simply issue a request for the new PRI */
825ef884685Srb request_pri(sp);
826ef884685Srb goto done;
827ef884685Srb default: /* ignore garbage or unknown message types */
828ef884685Srb goto done;
829ef884685Srb }
830ef884685Srb
831ef884685Srb /*
832ef884685Srb * If there is no pending PRI request, then we've received a
833ef884685Srb * bogus data message ... so ignore it.
834ef884685Srb */
835ef884685Srb
836ef884685Srb if (!(sp->state & DS_PRI_REQUESTED)) {
837ef884685Srb cmn_err(CE_WARN, "Received DS pri data without request");
838ef884685Srb goto done;
839ef884685Srb }
840ef884685Srb
841ef884685Srb /* response to a request therefore old PRI must be gone */
842ef884685Srb ASSERT(!(sp->state & DS_PRI_HAS_PRI));
843ef884685Srb ASSERT(sp->ds_pri_len == 0);
844ef884685Srb ASSERT(sp->ds_pri == NULL);
845ef884685Srb
846ef884685Srb /* response seq_num should match our request seq_num */
847ef884685Srb if (msgp->hdr.seq_num != sp->last_req_id) {
848ef884685Srb cmn_err(CE_WARN, "Received DS pri data out of sequence with "
8493597045eSnarayan "request");
850ef884685Srb goto done;
851ef884685Srb }
852ef884685Srb
853ef884685Srb pri_size = buflen - sizeof (msgp->hdr);
8544df55fdeSJanie Lu if (pri_size == 0) {
8554df55fdeSJanie Lu cmn_err(CE_WARN, "Received DS pri data of size 0");
8564df55fdeSJanie Lu goto done;
8574df55fdeSJanie Lu }
858ef884685Srb data = kmem_alloc(pri_size, KM_SLEEP);
859ef884685Srb sp->ds_pri = data;
860ef884685Srb sp->ds_pri_len = pri_size;
861ef884685Srb bcopy(msgp->data, data, sp->ds_pri_len);
862ef884685Srb sp->state &= ~DS_PRI_REQUESTED;
863ef884685Srb sp->state |= DS_PRI_HAS_PRI;
864ef884685Srb
865ef884685Srb sp->gencount++;
866ef884685Srb cv_broadcast(&sp->cv);
867ef884685Srb
868ef884685Srb done:;
869ef884685Srb mutex_exit(&sp->lock);
870ef884685Srb }
8714df55fdeSJanie Lu
8724df55fdeSJanie Lu /*
8734df55fdeSJanie Lu * Routine to get static PRI data from the Hypervisor.
8744df55fdeSJanie Lu * If successful, this PRI data is the last known PRI
8754df55fdeSJanie Lu * data generated since the last poweron reset.
8764df55fdeSJanie Lu */
8774df55fdeSJanie Lu static uint64_t
ds_get_hv_pri(ds_pri_state_t * sp)8784df55fdeSJanie Lu ds_get_hv_pri(ds_pri_state_t *sp)
8794df55fdeSJanie Lu {
8804df55fdeSJanie Lu uint64_t status;
8814df55fdeSJanie Lu uint64_t pri_size;
8824df55fdeSJanie Lu uint64_t buf_size;
8834df55fdeSJanie Lu uint64_t buf_pa;
8844df55fdeSJanie Lu caddr_t buf_va = NULL;
8854df55fdeSJanie Lu caddr_t pri_data;
8864df55fdeSJanie Lu
8874df55fdeSJanie Lu /*
8884df55fdeSJanie Lu * Get pri buffer size by calling hcall with buffer size 0.
8894df55fdeSJanie Lu */
8904df55fdeSJanie Lu pri_size = 0LL;
8914df55fdeSJanie Lu status = hv_mach_pri((uint64_t)0, &pri_size);
8924df55fdeSJanie Lu if (status == H_ENOTSUPPORTED || status == H_ENOACCESS) {
8937c18cbb1SSree Vemuri /*
8947c18cbb1SSree Vemuri * hv_mach_pri() is not supported on a guest domain.
8957c18cbb1SSree Vemuri * Unregister pboot API group to prevent failures.
8967c18cbb1SSree Vemuri */
8977c18cbb1SSree Vemuri (void) hsvc_unregister(&pboot_hsvc);
8987c18cbb1SSree Vemuri hsvc_pboot_available = B_FALSE;
8994df55fdeSJanie Lu DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri service is not "
9004df55fdeSJanie Lu "available. errorno: 0x%lx\n", status);
9017c18cbb1SSree Vemuri return (0);
9027c18cbb1SSree Vemuri } else if (pri_size == 0) {
9037c18cbb1SSree Vemuri return (1);
9047c18cbb1SSree Vemuri } else {
9057c18cbb1SSree Vemuri DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri pri size: 0x%lx\n",
9067c18cbb1SSree Vemuri pri_size);
9074df55fdeSJanie Lu }
9084df55fdeSJanie Lu
9094df55fdeSJanie Lu /*
9104df55fdeSJanie Lu * contig_mem_alloc requires size to be a power of 2.
9114df55fdeSJanie Lu * Increase size to next power of 2 if necessary.
9124df55fdeSJanie Lu */
913*de710d24SJosef 'Jeff' Sipek if (!ISP2(pri_size))
9144df55fdeSJanie Lu buf_size = 1 << highbit(pri_size);
9154df55fdeSJanie Lu DS_PRI_DBG("ds_get_hv_pri: buf_size = 0x%lx\n", buf_size);
9164df55fdeSJanie Lu
9174df55fdeSJanie Lu buf_va = contig_mem_alloc(buf_size);
9184df55fdeSJanie Lu if (buf_va == NULL)
9194df55fdeSJanie Lu return (1);
9204df55fdeSJanie Lu
9214df55fdeSJanie Lu buf_pa = va_to_pa(buf_va);
9224df55fdeSJanie Lu DS_PRI_DBG("ds_get_hv_pri: buf_pa 0x%lx\n", buf_pa);
9234df55fdeSJanie Lu status = hv_mach_pri(buf_pa, &pri_size);
9244df55fdeSJanie Lu DS_PRI_DBG("ds_get_hv_pri: hv_mach_pri status = 0x%lx\n", status);
9254df55fdeSJanie Lu
9264df55fdeSJanie Lu if (status == H_EOK) {
9274df55fdeSJanie Lu pri_data = kmem_alloc(pri_size, KM_SLEEP);
9284df55fdeSJanie Lu sp->ds_pri = pri_data;
9294df55fdeSJanie Lu sp->ds_pri_len = pri_size;
9304df55fdeSJanie Lu bcopy(buf_va, pri_data, sp->ds_pri_len);
9314df55fdeSJanie Lu sp->state |= DS_PRI_HAS_PRI;
9324df55fdeSJanie Lu sp->gencount++;
9334df55fdeSJanie Lu }
9344df55fdeSJanie Lu
9354df55fdeSJanie Lu contig_mem_free(buf_va, buf_size);
9364df55fdeSJanie Lu
9374df55fdeSJanie Lu return (status);
9384df55fdeSJanie Lu }
939