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 * Media independent RPC-like comms
28 */
29
30 #include <sys/types.h>
31 #include <sys/conf.h>
32 #include <sys/stat.h>
33 #include <sys/errno.h>
34 #include <sys/cmn_err.h>
35 #include <sys/ksynch.h>
36 #include <sys/kmem.h>
37 #include <sys/modctl.h>
38 #include <sys/ddi.h>
39 #include <sys/sunddi.h>
40
41 #include <sys/varargs.h>
42 #ifdef DS_DDICT
43 #include <sys/nsctl/contract.h>
44 #endif
45 #include "ncall.h"
46 #include "ncall_module.h"
47
48 #include <sys/nsctl/nsvers.h>
49
50 /*
51 * cb_ops functions.
52 */
53
54 static int ncallioctl(dev_t, int, intptr_t, int, cred_t *, int *);
55 static int ncallprint(dev_t, char *);
56
57
58 static struct cb_ops ncall_cb_ops = {
59 nulldev, /* open */
60 nulldev, /* close */
61 nulldev, /* strategy */
62 ncallprint,
63 nodev, /* dump */
64 nodev, /* read */
65 nodev, /* write */
66 ncallioctl,
67 nodev, /* devmap */
68 nodev, /* mmap */
69 nodev, /* segmap */
70 nochpoll, /* poll */
71 ddi_prop_op,
72 NULL, /* NOT a stream */
73 D_NEW | D_MP | D_64BIT,
74 CB_REV,
75 nodev, /* aread */
76 nodev, /* awrite */
77 };
78
79
80 /*
81 * dev_ops functions.
82 */
83
84 static int ncall_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
85 static int ncall_attach(dev_info_t *, ddi_attach_cmd_t);
86 static int ncall_detach(dev_info_t *, ddi_detach_cmd_t);
87
88 static struct dev_ops ncall_ops = {
89 DEVO_REV,
90 0,
91 ncall_getinfo,
92 nulldev, /* identify */
93 nulldev, /* probe */
94 ncall_attach,
95 ncall_detach,
96 nodev, /* reset */
97 &ncall_cb_ops,
98 (struct bus_ops *)0,
99 NULL /* power */
100 };
101
102 /*
103 * Module linkage.
104 */
105
106 extern struct mod_ops mod_driverops;
107
108 static struct modldrv modldrv = {
109 &mod_driverops,
110 "nws:Kernel Call:" ISS_VERSION_STR,
111 &ncall_ops
112 };
113
114 static struct modlinkage modlinkage = {
115 MODREV_1,
116 &modldrv,
117 0
118 };
119
120 typedef struct ncall_modinfo_s {
121 struct ncall_modinfo_s *next;
122 ncall_module_t *module;
123 } ncall_modinfo_t;
124
125 static dev_info_t *ncall_dip; /* Single DIP for driver */
126 static kmutex_t ncall_mutex;
127
128 static ncall_modinfo_t *ncall_modules;
129 static int ncall_active;
130
131 static ncall_node_t ncall_nodeinfo;
132
133 static int ncallgetnodes(intptr_t, int, int *);
134 extern void ncall_init_stub(void);
135
136 int
137 _init(void)
138 {
139 int error;
140
141 mutex_init(&ncall_mutex, NULL, MUTEX_DRIVER, NULL);
142
143 if ((error = mod_install(&modlinkage)) != 0) {
144 mutex_destroy(&ncall_mutex);
145 return (error);
146 }
147
148 return (0);
149 }
150
151
152 int
153 _fini(void)
154 {
155 int error;
156
157 if ((error = mod_remove(&modlinkage)) != 0)
158 return (error);
159
160 mutex_destroy(&ncall_mutex);
161 return (error);
162 }
163
164
165 int
166 _info(struct modinfo *modinfop)
167 {
168 return (mod_info(&modlinkage, modinfop));
169 }
170
171 static int
172 ncall_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
173 {
174 switch (cmd) {
175
176 case DDI_ATTACH:
177 ncall_dip = dip;
178
179 if (ddi_create_minor_node(dip, "c,ncall", S_IFCHR,
180 0, DDI_PSEUDO, 0) != DDI_SUCCESS)
181 goto failed;
182
183 ddi_report_dev(dip);
184
185 return (DDI_SUCCESS);
186
187 default:
188 return (DDI_FAILURE);
189 }
190
191 failed:
192 (void) ncall_detach(dip, DDI_DETACH);
193 return (DDI_FAILURE);
194 }
195
196
197 static int
198 ncall_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
199 {
200 switch (cmd) {
201
202 case DDI_DETACH:
203
204 /*
205 * If still active, then refuse to detach.
206 */
207
208 if (ncall_modules != NULL || ncall_active)
209 return (DDI_FAILURE);
210
211 /*
212 * Remove all minor nodes.
213 */
214
215 ddi_remove_minor_node(dip, NULL);
216 ncall_dip = NULL;
217
218 return (DDI_SUCCESS);
219
220 default:
221 return (DDI_FAILURE);
222 }
223 }
224
225
226 /* ARGSUSED */
227
228 static int
229 ncall_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
230 {
231 int rc = DDI_FAILURE;
232
233 switch (infocmd) {
234
235 case DDI_INFO_DEVT2DEVINFO:
236 *result = ncall_dip;
237 rc = DDI_SUCCESS;
238 break;
239
240 case DDI_INFO_DEVT2INSTANCE:
241 /*
242 * We only have a single instance.
243 */
244 *result = 0;
245 rc = DDI_SUCCESS;
246 break;
247
248 default:
249 break;
250 }
251
252 return (rc);
253 }
254
255
256 /* ARGSUSED */
257 static int
258 ncallprint(dev_t dev, char *str)
259 {
260 cmn_err(CE_WARN, "%s%d: %s", ddi_get_name(ncall_dip),
261 ddi_get_instance(ncall_dip), str);
262
263 return (0);
264 }
265
266
267 int
268 ncall_register_module(ncall_module_t *mp, ncall_node_t *nodep)
269 {
270 ncall_modinfo_t *new;
271 int rc = 0;
272
273 if (mp == NULL || mp->ncall_version != NCALL_MODULE_VER)
274 return (EINVAL);
275
276 new = kmem_alloc(sizeof (*new), KM_SLEEP);
277
278 if (new != NULL) {
279 new->module = mp;
280
281 mutex_enter(&ncall_mutex);
282
283 new->next = ncall_modules;
284 ncall_modules = new;
285
286 mutex_exit(&ncall_mutex);
287 } else {
288 rc = ENOMEM;
289 }
290
291 *nodep = ncall_nodeinfo; /* structure copy */
292 return (rc);
293 }
294
295
296 int
297 ncall_unregister_module(ncall_module_t *mod)
298 {
299 ncall_modinfo_t **mpp;
300 int rc = ESRCH;
301
302 mutex_enter(&ncall_mutex);
303
304 for (mpp = &ncall_modules; *mpp != NULL; mpp = &((*mpp)->next)) {
305 if ((*mpp)->module == mod) {
306 *mpp = (*mpp)->next;
307 rc = 0;
308 break;
309 }
310 }
311
312 mutex_exit(&ncall_mutex);
313
314 return (rc);
315 }
316
317
318 static int
319 ncall_stop(void)
320 {
321 ncall_modinfo_t *mod;
322 int rc = 0;
323
324 mutex_enter(&ncall_mutex);
325
326 while ((rc == 0) && ((mod = ncall_modules) != NULL)) {
327 mutex_exit(&ncall_mutex);
328
329 rc = (*mod->module->ncall_stop)();
330
331 mutex_enter(&ncall_mutex);
332 }
333
334 mutex_exit(&ncall_mutex);
335
336 return (rc);
337 }
338
339
340 /* ARGSUSED */
341 static int ncallioctl(dev_t dev, int cmd, intptr_t arg, int mode,
342 cred_t *crp, int *rvalp)
343 {
344 ncall_node_t node = { 0, };
345 int mirror;
346 int rc = 0;
347
348 *rvalp = 0;
349
350 if ((rc = drv_priv(crp)) != 0)
351 return (rc);
352
353 switch (cmd) {
354
355 case NC_IOC_START:
356 if (ncall_active) {
357 rc = EALREADY;
358 break;
359 }
360
361 if (ddi_copyin((void *)arg, &node, sizeof (node), mode) < 0)
362 return (EFAULT);
363
364 bcopy(&node, &ncall_nodeinfo, sizeof (ncall_nodeinfo));
365 ncall_init_stub();
366 ncall_active = 1;
367 break;
368
369 case NC_IOC_STOP:
370 ncall_active = 0;
371 rc = ncall_stop();
372 break;
373
374 case NC_IOC_GETNODE:
375 if (!ncall_active) {
376 rc = ENONET;
377 break;
378 }
379 if (ddi_copyout(&ncall_nodeinfo, (void *)arg,
380 sizeof (ncall_nodeinfo), mode) < 0) {
381 rc = EFAULT;
382 break;
383 }
384 mirror = ncall_mirror(ncall_nodeinfo.nc_nodeid);
385 /*
386 * can't return -1, as this will mask the ioctl
387 * failure, so return 0.
388 */
389 if (mirror == -1)
390 mirror = 0;
391 *rvalp = mirror;
392 break;
393
394 case NC_IOC_GETNETNODES:
395 rc = ncallgetnodes(arg, mode, rvalp);
396 break;
397
398 case NC_IOC_PING:
399 if (!ncall_active) {
400 rc = ENONET;
401 break;
402 }
403
404 if (ddi_copyin((void *)arg, &node, sizeof (node), mode) < 0) {
405 rc = EFAULT;
406 break;
407 }
408
409 node.nc_nodename[sizeof (node.nc_nodename)-1] = '\0';
410 rc = ncall_ping(node.nc_nodename, rvalp);
411 break;
412
413 default:
414 rc = EINVAL;
415 break;
416 }
417
418 return (rc);
419 }
420
421
422 void
423 ncall_register_svc(int svc_id, void (*func)(ncall_t *, int *))
424 {
425 if (ncall_modules)
426 (*ncall_modules->module->ncall_register_svc)(svc_id, func);
427 }
428
429
430 void
431 ncall_unregister_svc(int svc_id)
432 {
433 if (ncall_modules)
434 (*ncall_modules->module->ncall_unregister_svc)(svc_id);
435 }
436
437
438 int
439 ncall_nodeid(char *nodename)
440 {
441 if (ncall_modules)
442 return ((ncall_modules->module->ncall_nodeid)(nodename));
443 else
444 return (0);
445 }
446
447
448 char *
449 ncall_nodename(int nodeid)
450 {
451 if (ncall_modules)
452 return ((*ncall_modules->module->ncall_nodename)(nodeid));
453 else
454 return ("unknown");
455 }
456
457
458 int
459 ncall_mirror(int nodeid)
460 {
461 if (ncall_modules)
462 return ((*ncall_modules->module->ncall_mirror)(nodeid));
463 else
464 return (-1);
465 }
466
467
468 int
469 ncall_self(void)
470 {
471 if (ncall_modules)
472 return ((*ncall_modules->module->ncall_self)());
473 else
474 return (-1);
475 }
476
477
478 int
479 ncall_alloc(int host_id, int flags, int net, ncall_t **ncall_p)
480 {
481 int rc = ENOLINK;
482
483 if (ncall_modules)
484 rc = (*ncall_modules->module->ncall_alloc)(host_id,
485 flags, net, ncall_p);
486
487 return (rc);
488 }
489
490
491 int
492 ncall_timedsend(ncall_t *ncall, int flags, int svc_id,
493 struct timeval *t, ...)
494 {
495 va_list ap;
496 int rc = ENOLINK;
497
498 va_start(ap, t);
499
500 if (ncall_modules)
501 rc = (*ncall_modules->module->ncall_timedsend)(ncall, flags,
502 svc_id, t, ap);
503
504 va_end(ap);
505
506 return (rc);
507 }
508
509 int
510 ncall_timedsendnotify(ncall_t *ncall, int flags, int svc_id,
511 struct timeval *t, void (*ncall_callback)(ncall_t *, void *),
512 void *vptr, ...)
513 {
514 va_list ap;
515 int rc = ENOLINK;
516
517 va_start(ap, vptr);
518
519 if (ncall_modules)
520 rc = (*ncall_modules->module->ncall_timedsendnotify)(ncall,
521 flags, svc_id, t, ncall_callback, vptr, ap);
522 va_end(ap);
523
524 return (rc);
525 }
526
527 int
528 ncall_broadcast(ncall_t *ncall, int flags, int svc_id,
529 struct timeval *t, ...)
530 {
531 va_list ap;
532 int rc = ENOLINK;
533
534 va_start(ap, t);
535
536 if (ncall_modules)
537 rc = (*ncall_modules->module->ncall_broadcast)(ncall, flags,
538 svc_id, t, ap);
539 va_end(ap);
540
541 return (rc);
542 }
543
544
545 int
546 ncall_send(ncall_t *ncall, int flags, int svc_id, ...)
547 {
548 va_list ap;
549 int rc = ENOLINK;
550
551 va_start(ap, svc_id);
552
553 if (ncall_modules)
554 rc = (*ncall_modules->module->ncall_timedsend)(ncall, flags,
555 svc_id, NULL, ap);
556
557 va_end(ap);
558
559 return (rc);
560 }
561
562
563 int
564 ncall_read_reply(ncall_t *ncall, int n, ...)
565 {
566 va_list ap;
567 int rc = ENOLINK;
568
569 va_start(ap, n);
570
571 if (ncall_modules)
572 rc = (*ncall_modules->module->ncall_read_reply)(ncall, n, ap);
573
574 va_end(ap);
575
576 return (rc);
577 }
578
579
580 void
581 ncall_reset(ncall_t *ncall)
582 {
583 if (ncall_modules)
584 (*ncall_modules->module->ncall_reset)(ncall);
585 }
586
587
588 void
589 ncall_free(ncall_t *ncall)
590 {
591 if (ncall_modules)
592 (*ncall_modules->module->ncall_free)(ncall);
593 }
594
595
596 int
597 ncall_put_data(ncall_t *ncall, void *data, int len)
598 {
599 int rc = ENOLINK;
600
601 if (ncall_modules)
602 rc = (*ncall_modules->module->ncall_put_data)(ncall, data, len);
603
604 return (rc);
605 }
606
607
608 int
609 ncall_get_data(ncall_t *ncall, void *data, int len)
610 {
611 int rc = ENOLINK;
612
613 if (ncall_modules)
614 rc = (*ncall_modules->module->ncall_get_data)(ncall, data, len);
615
616 return (rc);
617 }
618
619
620 int
621 ncall_sender(ncall_t *ncall)
622 {
623 int rc = -1;
624
625 if (ncall_modules)
626 rc = (*ncall_modules->module->ncall_sender)(ncall);
627
628 return (rc);
629 }
630
631
632 void
633 ncall_reply(ncall_t *ncall, ...)
634 {
635 va_list ap;
636
637 if (ncall_modules) {
638 va_start(ap, ncall);
639
640 (*ncall_modules->module->ncall_reply)(ncall, ap);
641
642 va_end(ap);
643 }
644 }
645
646
647 void
648 ncall_pend(ncall_t *ncall)
649 {
650 if (ncall_modules)
651 (*ncall_modules->module->ncall_pend)(ncall);
652 }
653
654
655 void
656 ncall_done(ncall_t *ncall)
657 {
658 if (ncall_modules)
659 (*ncall_modules->module->ncall_done)(ncall);
660 }
661
662 int
663 ncall_ping(char *nodename, int *up)
664 {
665 int rc = ENOLINK;
666 if (ncall_modules)
667 rc = (*ncall_modules->module->ncall_ping)(nodename, up);
668 return (rc);
669 }
670
671 int
672 ncall_maxnodes()
673 {
674 int rc = 0;
675
676 if (ncall_modules)
677 rc = (*ncall_modules->module->ncall_maxnodes)();
678
679 return (rc);
680 }
681
682 int
683 ncall_nextnode(void **vptr)
684 {
685 int rc = 0;
686
687 if (ncall_modules)
688 rc = (*ncall_modules->module->ncall_nextnode)(vptr);
689
690 return (rc);
691 }
692
693 int
694 ncall_errcode(ncall_t *ncall, int *result)
695 {
696 int rc = ENOLINK;
697 if (ncall_modules)
698 rc = (*ncall_modules->module->ncall_errcode)(ncall, result);
699
700 return (rc);
701 }
702
703 static int
704 ncallgetnodes(intptr_t uaddr, int mode, int *rvalp)
705 {
706 ncall_node_t *nodelist;
707 int slot;
708 int rc;
709 int nodecnt;
710 int nodeid;
711 void *sequence;
712 char *nodename;
713
714 rc = 0;
715
716 nodecnt = ncall_maxnodes();
717 if (nodecnt <= 0) {
718 return (ENONET);
719 }
720
721 /*
722 * If the user passes up a null address argument, then
723 * he/she doesn't want the actual nodes, but the configured
724 * maximum, so space can be correctly allocated.
725 */
726
727 if (uaddr == NULL) {
728 *rvalp = nodecnt;
729 return (0);
730 }
731 nodelist = kmem_zalloc(sizeof (*nodelist) * nodecnt, KM_SLEEP);
732
733 slot = 0;
734 sequence = NULL;
735 while ((nodeid = ncall_nextnode(&sequence)) > 0) {
736 nodename = ncall_nodename(nodeid);
737 /*
738 * There is a small window where nextnode can
739 * return a valid nodeid, and it being disabled
740 * which will get nodename to return "".
741 * Discard the nodeid if this happens.
742 */
743 if (strlen(nodename) > 0) {
744 int size = sizeof (nodelist[slot].nc_nodename) - 1;
745 ASSERT(slot < nodecnt);
746 /*
747 * make sure its null terminated when it
748 * gets to userland.
749 */
750 nodelist[slot].nc_nodename[size] = 0;
751 (void) strncpy(nodelist[slot].nc_nodename, nodename,
752 size);
753 nodelist[slot].nc_nodeid = nodeid;
754 slot++;
755 }
756 }
757 if (ddi_copyout(nodelist, (void *)uaddr, sizeof (*nodelist) * slot,
758 mode) < 0) {
759 rc = EFAULT;
760 } else {
761 /*
762 * tell them how many have come back.
763 */
764 *rvalp = slot;
765 }
766 kmem_free(nodelist, sizeof (*nodelist) * nodecnt);
767 return (rc);
768 }