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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * Pseudo devices are devices implemented entirely in software; pseudonex
29 * (pseudo) is the traditional nexus for pseudodevices. Instances are
30 * typically specified via driver.conf files; e.g. a leaf device which
31 * should be attached below pseudonex will have an entry like:
32 *
33 * name="foo" parent="/pseudo" instance=0;
34 *
35 * pseudonex also supports the devctl (see <sys/devctl.h>) interface via
36 * its :devctl minor node. This allows priveleged userland applications to
37 * online/offline children of pseudo as needed.
38 *
39 * In general, we discourage widespread use of this tactic, as it may lead to a
40 * proliferation of nodes in /pseudo. It is preferred that implementors update
41 * pseudo.conf, adding another 'pseudo' nexus child of /pseudo, and then use
42 * that for their collection of device nodes. To do so, add a driver alias
43 * for the name of the nexus child and a line in pseudo.conf such as:
44 *
45 * name="foo" parent="/pseudo" instance=<n> valid-children="bar","baz";
46 *
47 * Setting 'valid-children' is important because we have an annoying problem;
48 * we need to prevent pseudo devices with 'parent="pseudo"' set from binding
49 * to our new pseudonex child node. A better way might be to teach the
50 * spec-node code to understand that parent="pseudo" really means
51 * parent="/pseudo".
52 *
53 * At some point in the future, it would be desirable to extend the instance
54 * database to include nexus children of pseudo. Then we could use devctl
55 * or devfs to online nexus children of pseudo, auto-selecting an instance #,
56 * and the instance number selected would be preserved across reboot in
57 * path_to_inst.
58 */
59
60 #include <sys/types.h>
61 #include <sys/cmn_err.h>
62 #include <sys/conf.h>
63 #include <sys/ddi.h>
64 #include <sys/ddi_impldefs.h>
65 #include <sys/devops.h>
66 #include <sys/instance.h>
67 #include <sys/modctl.h>
68 #include <sys/open.h>
69 #include <sys/stat.h>
70 #include <sys/sunddi.h>
71 #include <sys/sunndi.h>
72 #include <sys/systm.h>
73 #include <sys/mkdev.h>
74
75 /*
76 * Config information
77 */
78 static int pseudonex_intr_op(dev_info_t *dip, dev_info_t *rdip,
79 ddi_intr_op_t op, ddi_intr_handle_impl_t *hdlp, void *result);
80
81 static int pseudonex_attach(dev_info_t *, ddi_attach_cmd_t);
82 static int pseudonex_detach(dev_info_t *, ddi_detach_cmd_t);
83 static int pseudonex_open(dev_t *, int, int, cred_t *);
84 static int pseudonex_close(dev_t, int, int, cred_t *);
85 static int pseudonex_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
86 static int pseudonex_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *,
87 void *);
88
89 static void *pseudonex_state;
90
91 typedef struct pseudonex_state {
92 dev_info_t *pnx_devi;
93 } pseudonex_state_t;
94
95 static struct bus_ops pseudonex_bus_ops = {
96 BUSO_REV,
97 nullbusmap, /* bus_map */
98 NULL, /* bus_get_intrspec */
99 NULL, /* bus_add_intrspec */
100 NULL, /* bus_remove_intrspec */
101 i_ddi_map_fault, /* bus_map_fault */
102 ddi_no_dma_map, /* bus_dma_map */
103 ddi_no_dma_allochdl, /* bus_dma_allochdl */
104 NULL, /* bus_dma_freehdl */
105 NULL, /* bus_dma_bindhdl */
106 NULL, /* bus_dma_unbindhdl */
107 NULL, /* bus_dma_flush */
108 NULL, /* bus_dma_win */
109 NULL, /* bus_dma_ctl */
110 pseudonex_ctl, /* bus_ctl */
111 ddi_bus_prop_op, /* bus_prop_op */
112 0, /* bus_get_eventcookie */
113 0, /* bus_add_eventcall */
114 0, /* bus_remove_eventcall */
115 0, /* bus_post_event */
116 NULL, /* bus_intr_ctl */
117 NULL, /* bus_config */
118 NULL, /* bus_unconfig */
119 NULL, /* bus_fm_init */
120 NULL, /* bus_fm_fini */
121 NULL, /* bus_fm_access_enter */
122 NULL, /* bus_fm_access_exit */
123 NULL, /* bus_power */
124 pseudonex_intr_op /* bus_intr_op */
125 };
126
127 static struct cb_ops pseudonex_cb_ops = {
128 pseudonex_open, /* open */
129 pseudonex_close, /* close */
130 nodev, /* strategy */
131 nodev, /* print */
132 nodev, /* dump */
133 nodev, /* read */
134 nodev, /* write */
135 pseudonex_ioctl, /* ioctl */
136 nodev, /* devmap */
137 nodev, /* mmap */
138 nodev, /* segmap */
139 nochpoll, /* poll */
140 ddi_prop_op, /* cb_prop_op */
141 0, /* streamtab */
142 D_MP | D_NEW | D_HOTPLUG /* Driver compatibility flag */
143 };
144
145 static struct dev_ops pseudo_ops = {
146 DEVO_REV, /* devo_rev, */
147 0, /* refcnt */
148 ddi_getinfo_1to1, /* info */
149 nulldev, /* identify */
150 nulldev, /* probe */
151 pseudonex_attach, /* attach */
152 pseudonex_detach, /* detach */
153 nodev, /* reset */
154 &pseudonex_cb_ops, /* driver operations */
155 &pseudonex_bus_ops, /* bus operations */
156 nulldev, /* power */
157 ddi_quiesce_not_needed, /* quiesce */
158 };
159
160 /*
161 * Module linkage information for the kernel.
162 */
163 static struct modldrv modldrv = {
164 &mod_driverops,
165 "nexus driver for 'pseudo' 1.31",
166 &pseudo_ops,
167 };
168
169 static struct modlinkage modlinkage = {
170 MODREV_1, { (void *)&modldrv, NULL }
171 };
172
173 int
174 _init(void)
175 {
176 int err;
177
178 if ((err = ddi_soft_state_init(&pseudonex_state,
179 sizeof (pseudonex_state_t), 0)) != 0) {
180 return (err);
181 }
182 if ((err = mod_install(&modlinkage)) != 0) {
183 ddi_soft_state_fini(&pseudonex_state);
184 return (err);
185 }
186 return (0);
187 }
188
189 int
190 _fini(void)
191 {
192 int err;
193
194 if ((err = mod_remove(&modlinkage)) != 0)
195 return (err);
196 ddi_soft_state_fini(&pseudonex_state);
197 return (0);
198 }
199
200 int
201 _info(struct modinfo *modinfop)
202 {
203 return (mod_info(&modlinkage, modinfop));
204 }
205
206 /*ARGSUSED*/
207 static int
208 pseudonex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
209 {
210 int instance;
211 pseudonex_state_t *pnx_state;
212
213 switch (cmd) {
214 case DDI_ATTACH:
215 break;
216 case DDI_RESUME:
217 return (DDI_SUCCESS);
218 default:
219 return (DDI_FAILURE);
220 }
221
222 /*
223 * Save the devi for this instance in the soft_state data.
224 */
225 instance = ddi_get_instance(devi);
226 if (ddi_soft_state_zalloc(pseudonex_state, instance) != DDI_SUCCESS)
227 return (DDI_FAILURE);
228 pnx_state = ddi_get_soft_state(pseudonex_state, instance);
229 pnx_state->pnx_devi = devi;
230
231 if (ddi_create_minor_node(devi, "devctl", S_IFCHR, instance,
232 DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
233 ddi_remove_minor_node(devi, NULL);
234 ddi_soft_state_free(pseudonex_state, instance);
235 return (DDI_FAILURE);
236 }
237 ddi_report_dev(devi);
238 return (DDI_SUCCESS);
239 }
240
241 /*ARGSUSED*/
242 static int
243 pseudonex_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
244 {
245 int instance = ddi_get_instance(devi);
246
247 if (cmd == DDI_SUSPEND)
248 return (DDI_SUCCESS);
249
250 ddi_remove_minor_node(devi, NULL);
251 ddi_soft_state_free(pseudonex_state, instance);
252 return (DDI_SUCCESS);
253 }
254
255 /*ARGSUSED*/
256 static int
257 pseudonex_open(dev_t *devp, int flags, int otyp, cred_t *credp)
258 {
259 int instance;
260
261 if (otyp != OTYP_CHR)
262 return (EINVAL);
263
264 instance = getminor(*devp);
265 if (ddi_get_soft_state(pseudonex_state, instance) == NULL)
266 return (ENXIO);
267
268 return (0);
269 }
270
271 /*ARGSUSED*/
272 static int
273 pseudonex_close(dev_t dev, int flags, int otyp, cred_t *credp)
274 {
275 int instance;
276
277 if (otyp != OTYP_CHR)
278 return (EINVAL);
279
280 instance = getminor(dev);
281 if (ddi_get_soft_state(pseudonex_state, instance) == NULL)
282 return (ENXIO);
283
284 return (0);
285 }
286
287 /*ARGSUSED*/
288 static int
289 pseudonex_ioctl(dev_t dev,
290 int cmd, intptr_t arg, int mode, cred_t *cred_p, int *rval_p)
291 {
292 int instance;
293 pseudonex_state_t *pnx_state;
294
295 instance = getminor(dev);
296 if ((pnx_state = ddi_get_soft_state(pseudonex_state, instance)) == NULL)
297 return (ENXIO);
298 ASSERT(pnx_state->pnx_devi);
299 return (ndi_devctl_ioctl(pnx_state->pnx_devi, cmd, arg, mode, 0));
300 }
301
302 /*
303 * pseudonex_intr_op: pseudonex convert an interrupt number to an
304 * interrupt. NO OP for pseudo drivers.
305 */
306 /*ARGSUSED*/
307 static int
308 pseudonex_intr_op(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op,
309 ddi_intr_handle_impl_t *hdlp, void *result)
310 {
311 return (DDI_FAILURE);
312 }
313
314 static int
315 pseudonex_check_assignment(dev_info_t *child, int test_inst)
316 {
317 dev_info_t *tdip;
318 kmutex_t *dmp;
319 const char *childname = ddi_driver_name(child);
320 major_t childmaj = ddi_name_to_major((char *)childname);
321
322 dmp = &devnamesp[childmaj].dn_lock;
323 LOCK_DEV_OPS(dmp);
324 for (tdip = devnamesp[childmaj].dn_head;
325 tdip != NULL; tdip = ddi_get_next(tdip)) {
326 /* is this the current node? */
327 if (tdip == child)
328 continue;
329 /* is this a duplicate instance? */
330 if (test_inst == ddi_get_instance(tdip)) {
331 UNLOCK_DEV_OPS(dmp);
332 return (DDI_FAILURE);
333 }
334 }
335 UNLOCK_DEV_OPS(dmp);
336 return (DDI_SUCCESS);
337 }
338
339 /*
340 * This is a nasty, slow hack. But we're stuck with it until we do some
341 * major surgery on the instance assignment subsystem, to allow pseudonode
342 * instance assignment to be tracked there.
343 *
344 * To auto-assign an instance number, we exhaustively search the instance
345 * list for each possible instance number until we find one which is unused.
346 */
347 static int
348 pseudonex_auto_assign(dev_info_t *child)
349 {
350 dev_info_t *tdip;
351 kmutex_t *dmp;
352 const char *childname = ddi_driver_name(child);
353 major_t childmaj = ddi_name_to_major((char *)childname);
354 int inst = 0;
355
356 dmp = &devnamesp[childmaj].dn_lock;
357 LOCK_DEV_OPS(dmp);
358 for (inst = 0; inst <= MAXMIN32; inst++) {
359 for (tdip = devnamesp[childmaj].dn_head; tdip != NULL;
360 tdip = ddi_get_next(tdip)) {
361 /* is this the current node? */
362 if (tdip == child)
363 continue;
364 if (inst == ddi_get_instance(tdip)) {
365 break;
366 }
367 }
368 if (tdip == NULL) {
369 UNLOCK_DEV_OPS(dmp);
370 return (inst);
371 }
372 }
373 UNLOCK_DEV_OPS(dmp);
374 return (-1);
375 }
376
377 static int
378 pseudonex_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
379 void *arg, void *result)
380 {
381 switch (ctlop) {
382 case DDI_CTLOPS_REPORTDEV:
383 if (rdip == NULL)
384 return (DDI_FAILURE);
385 cmn_err(CE_CONT, "?pseudo-device: %s%d\n",
386 ddi_driver_name(rdip), ddi_get_instance(rdip));
387 return (DDI_SUCCESS);
388
389 case DDI_CTLOPS_INITCHILD:
390 {
391 char name[12]; /* enough for a decimal integer */
392 int instance = -1;
393 dev_info_t *child = (dev_info_t *)arg;
394 const char *childname = ddi_driver_name(child);
395 char **childlist;
396 uint_t nelems;
397 int auto_assign = 0;
398
399 /*
400 * If this pseudonex node has a valid-children property,
401 * then that acts as an access control list for children
402 * allowed to attach beneath this node. Honor it.
403 */
404 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip,
405 DDI_PROP_DONTPASS, "valid-children", &childlist,
406 &nelems) == DDI_PROP_SUCCESS) {
407 int i, ok = 0;
408 for (i = 0; i < nelems; i++) {
409 if (strcmp(childlist[i], childname) == 0) {
410 ok = 1;
411 break;
412 }
413 }
414 ddi_prop_free(childlist);
415 if (!ok)
416 return (DDI_FAILURE);
417 }
418
419 /*
420 * Look up the "instance" property. If it does not exist,
421 * check to see if the "auto-assign-instance" property is set.
422 * If not, default to using instance 0; while not ideal, this
423 * is a legacy behavior we must continue to support.
424 */
425 instance = ddi_prop_get_int(DDI_DEV_T_ANY, child,
426 DDI_PROP_DONTPASS, "instance", -1);
427 auto_assign = ddi_prop_exists(DDI_DEV_T_ANY, child,
428 DDI_PROP_DONTPASS, "auto-assign-instance");
429 NDI_CONFIG_DEBUG((CE_NOTE,
430 "pseudonex: DDI_CTLOPS_INITCHILD(instance=%d, "
431 "auto-assign=%d)", instance, auto_assign));
432
433 if (instance != -1 && auto_assign != 0) {
434 NDI_CONFIG_DEBUG((CE_NOTE, "both instance and "
435 "auto-assign-instance properties specified. "
436 "Node rejected."));
437 return (DDI_FAILURE);
438 }
439
440 if (instance == -1 && auto_assign == 0) {
441 /* default to instance 0 if not specified */
442 NDI_CONFIG_DEBUG((CE_NOTE, "defaulting to 0"));
443 instance = 0;
444 }
445
446 /*
447 * If an instance has been specified, determine if this
448 * instance is already in use; if we need to pick an instance,
449 * we do it here.
450 */
451 if (auto_assign) {
452 if ((instance = pseudonex_auto_assign(child)) == -1) {
453 NDI_CONFIG_DEBUG((CE_NOTE, "failed to "
454 "auto-select instance for %s", childname));
455 return (DDI_FAILURE);
456 }
457 NDI_CONFIG_DEBUG((CE_NOTE,
458 "auto-selected instance for %s: %d",
459 childname, instance));
460 } else {
461 if (pseudonex_check_assignment(child, instance) ==
462 DDI_FAILURE) {
463 NDI_CONFIG_DEBUG((CE_WARN,
464 "Duplicate instance %d of node \"%s\" "
465 "ignored.", instance, childname));
466 return (DDI_FAILURE);
467 }
468 NDI_CONFIG_DEBUG((CE_NOTE,
469 "using fixed-assignment instance for %s: %d",
470 childname, instance));
471 }
472
473 /*
474 * Attach the instance number to the node. This allows
475 * us to have multiple instances of the same pseudo
476 * device, they will be named 'device@instance'. If this
477 * breaks programs, we may need to special-case instance 0
478 * into 'device'. Ick. devlinks appears to handle the
479 * new names ok, so if only names in /dev are used
480 * this may not be necessary.
481 */
482 (void) snprintf(name, sizeof (name), "%d", instance);
483 DEVI(child)->devi_instance = instance;
484 ddi_set_name_addr(child, name);
485 return (DDI_SUCCESS);
486 }
487
488 case DDI_CTLOPS_UNINITCHILD:
489 {
490 dev_info_t *child = (dev_info_t *)arg;
491
492 NDI_CONFIG_DEBUG((CE_NOTE,
493 "DDI_CTLOPS_UNINITCHILD(%s, instance=%d)",
494 ddi_driver_name(child), DEVI(child)->devi_instance));
495
496 ddi_set_name_addr(child, NULL);
497
498 return (DDI_SUCCESS);
499 }
500
501 case DDI_CTLOPS_DMAPMAPC:
502 case DDI_CTLOPS_REPORTINT:
503 case DDI_CTLOPS_REGSIZE:
504 case DDI_CTLOPS_NREGS:
505 case DDI_CTLOPS_SIDDEV:
506 case DDI_CTLOPS_SLAVEONLY:
507 case DDI_CTLOPS_AFFINITY:
508 case DDI_CTLOPS_POKE:
509 case DDI_CTLOPS_PEEK:
510 /*
511 * These ops correspond to functions that "shouldn't" be called
512 * by a pseudo driver. So we whine when we're called.
513 */
514 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n",
515 ddi_driver_name(dip), ddi_get_instance(dip), ctlop,
516 ddi_driver_name(rdip), ddi_get_instance(rdip));
517 return (DDI_FAILURE);
518
519 case DDI_CTLOPS_ATTACH:
520 case DDI_CTLOPS_BTOP:
521 case DDI_CTLOPS_BTOPR:
522 case DDI_CTLOPS_DETACH:
523 case DDI_CTLOPS_DVMAPAGESIZE:
524 case DDI_CTLOPS_IOMIN:
525 case DDI_CTLOPS_POWER:
526 case DDI_CTLOPS_PTOB:
527 default:
528 /*
529 * The ops that we pass up (default). We pass up memory
530 * allocation oriented ops that we receive - these may be
531 * associated with pseudo HBA drivers below us with target
532 * drivers below them that use ddi memory allocation
533 * interfaces like scsi_alloc_consistent_buf.
534 */
535 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
536 }
537 }