?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / ipp / ippctl.c
blob8d0a93605fffc118ac74c6a001350efab5643535
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 * IP Policy Framework config driver
29 */
30
31 #include <sys/types.h>
32 #include <sys/cmn_err.h>
33 #include <sys/kmem.h>
34 #include <sys/errno.h>
35 #include <sys/cpuvar.h>
36 #include <sys/open.h>
37 #include <sys/stat.h>
38 #include <sys/conf.h>
39 #include <sys/ddi.h>
40 #include <sys/sunddi.h>
41 #include <sys/modctl.h>
42 #include <sys/stream.h>
43 #include <ipp/ipp.h>
44 #include <ipp/ippctl.h>
45 #include <sys/nvpair.h>
46 #include <sys/policy.h>
47
48 /*
49 * Debug switch.
50 */
51
52 #if defined(DEBUG)
53 #define IPPCTL_DEBUG
54 #endif
55
56 /*
57 * Debug macros.
58 */
59
60 #ifdef IPPCTL_DEBUG
61
62 #define DBG_MODLINK 0x00000001ull
63 #define DBG_DEVOPS 0x00000002ull
64 #define DBG_CBOPS 0x00000004ull
65
66 static uint64_t ippctl_debug_flags =
67 /*
68 * DBG_MODLINK |
69 * DBG_DEVOPS |
70 * DBG_CBOPS |
71 */
72 0;
73
74 static kmutex_t debug_mutex[1];
75
76 /*PRINTFLIKE3*/
77 static void ippctl_debug(uint64_t, char *, char *, ...)
78 __PRINTFLIKE(3);
79
80 #define DBG0(_type, _fmt) \
81 ippctl_debug((_type), __FN__, (_fmt));
82
83 #define DBG1(_type, _fmt, _a1) \
84 ippctl_debug((_type), __FN__, (_fmt), (_a1));
85
86 #define DBG2(_type, _fmt, _a1, _a2) \
87 ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2));
88
89 #define DBG3(_type, _fmt, _a1, _a2, _a3) \
90 ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2), \
91 (_a3));
92
93 #define DBG4(_type, _fmt, _a1, _a2, _a3, _a4) \
94 ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2), \
95 (_a3), (_a4));
96
97 #define DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5) \
98 ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2), \
99 (_a3), (_a4), (_a5));
100
101 #else /* IPPCTL_DBG */
102
103 #define DBG0(_type, _fmt)
104 #define DBG1(_type, _fmt, _a1)
105 #define DBG2(_type, _fmt, _a1, _a2)
106 #define DBG3(_type, _fmt, _a1, _a2, _a3)
107 #define DBG4(_type, _fmt, _a1, _a2, _a3, _a4)
108 #define DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5)
109
110 #endif /* IPPCTL_DBG */
111
112 /*
113 * cb_ops
114 */
115
116 static int ippctl_open(dev_t *, int, int, cred_t *);
117 static int ippctl_close(dev_t, int, int, cred_t *);
118 static int ippctl_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
119
120 static struct cb_ops ippctl_cb_ops = {
121 ippctl_open, /* cb_open */
122 ippctl_close, /* cb_close */
123 nodev, /* cb_strategy */
124 nodev, /* cb_print */
125 nodev, /* cb_dump */
126 nodev, /* cb_read */
127 nodev, /* cb_write */
128 ippctl_ioctl, /* cb_ioctl */
129 nodev, /* cb_devmap */
130 nodev, /* cb_mmap */
131 nodev, /* cb_segmap */
132 nochpoll, /* cb_chpoll */
133 ddi_prop_op, /* cb_prop_op */
134 0, /* cb_str */
135 D_NEW | D_MP, /* cb_flag */
136 CB_REV, /* cb_rev */
137 nodev, /* cb_aread */
138 nodev /* cb_awrite */
139 };
140
141 /*
142 * dev_ops
143 */
144
145 static int ippctl_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
146 static int ippctl_attach(dev_info_t *, ddi_attach_cmd_t);
147 static int ippctl_detach(dev_info_t *, ddi_detach_cmd_t);
148
149 static struct dev_ops ippctl_dev_ops = {
150 DEVO_REV, /* devo_rev, */
151 0, /* devo_refcnt */
152 ippctl_info, /* devo_getinfo */
153 nulldev, /* devo_identify */
154 nulldev, /* devo_probe */
155 ippctl_attach, /* devo_attach */
156 ippctl_detach, /* devo_detach */
157 nodev, /* devo_reset */
158 &ippctl_cb_ops, /* devo_cb_ops */
159 NULL, /* devo_bus_ops */
160 NULL, /* devo_power */
161 ddi_quiesce_not_needed, /* devo_quiesce */
162 };
163
164 static struct modldrv modldrv = {
165 &mod_driverops,
166 "IP Policy Configuration Driver",
167 &ippctl_dev_ops,
168 };
169
170 static struct modlinkage modlinkage = {
171 MODREV_1,
172 &modldrv,
173 NULL
174 };
175
176 /*
177 * Local definitions, types and prototypes.
178 */
179
180 #define MAXUBUFLEN (1 << 16)
181
182 #define FREE_TEXT(_string) \
183 kmem_free((_string), strlen(_string) + 1)
184
185 #define FREE_TEXT_ARRAY(_array, _nelt) \
186 { \
187 int j; \
188 \
189 for (j = 0; j < (_nelt); j++) \
190 if ((_array)[j] != NULL) \
191 FREE_TEXT((_array)[j]); \
192 kmem_free((_array), (_nelt) * sizeof (char *)); \
193 }
194
195 typedef struct ippctl_buf ippctl_buf_t;
196
197 struct ippctl_buf {
198 char *buf;
199 size_t buflen;
200 };
201
202 static int ippctl_copyin(caddr_t, int, char **, size_t *);
203 static int ippctl_copyout(caddr_t, int, char *, size_t);
204 static int ippctl_extract_op(nvlist_t *, uint8_t *);
205 static int ippctl_extract_aname(nvlist_t *, char **);
206 static int ippctl_extract_modname(nvlist_t *, char **);
207 static int ippctl_attach_modname(nvlist_t *nvlp, char *val);
208 static int ippctl_attach_modname_array(nvlist_t *nvlp, char **val, int);
209 static int ippctl_attach_aname_array(nvlist_t *nvlp, char **val, int);
210 static int ippctl_extract_flags(nvlist_t *, ipp_flags_t *);
211 static int ippctl_cmd(char *, size_t, size_t *);
212 static int ippctl_action_create(char *, char *, nvlist_t *, ipp_flags_t);
213 static int ippctl_action_destroy(char *, ipp_flags_t);
214 static int ippctl_action_modify(char *, nvlist_t *, ipp_flags_t);
215 static int ippctl_action_info(char *, ipp_flags_t);
216 static int ippctl_action_mod(char *);
217 static int ippctl_list_mods(void);
218 static int ippctl_mod_list_actions(char *);
219 static int ippctl_data(char **, size_t *, size_t *);
220 static void ippctl_flush(void);
221 static int ippctl_add_nvlist(nvlist_t *, int);
222 static int ippctl_callback(nvlist_t *, void *);
223 static int ippctl_set_rc(int);
224 static void ippctl_alloc(int);
225 static void ippctl_realloc(void);
226 static void ippctl_free(void);
227
228 /*
229 * Global data
230 */
231
232 static dev_info_t *ippctl_dip = NULL;
233 static kmutex_t ippctl_lock;
234 static boolean_t ippctl_busy;
235 static ippctl_buf_t *ippctl_array = NULL;
236 static int ippctl_limit = -1;
237 static int ippctl_rindex = -1;
238 static int ippctl_windex = -1;
239
240 /*
241 * Module linkage functions
242 */
243
244 #define __FN__ "_init"
245 int
246 _init(
247 void)
248 {
249 int rc;
250
251 if ((rc = mod_install(&modlinkage)) != 0) {
252 DBG0(DBG_MODLINK, "mod_install failed\n");
253 return (rc);
254 }
255
256 return (rc);
257 }
258 #undef __FN__
259
260 #define __FN__ "_fini"
261 int
262 _fini(
263 void)
264 {
265 int rc;
266
267 if ((rc = mod_remove(&modlinkage)) == 0) {
268 return (rc);
269 }
270
271 DBG0(DBG_MODLINK, "mod_remove failed\n");
272 return (rc);
273 }
274 #undef __FN__
275
276 #define __FN__ "_info"
277 int
278 _info(
279 struct modinfo *modinfop)
280 {
281 DBG0(DBG_MODLINK, "calling mod_info\n");
282 return (mod_info(&modlinkage, modinfop));
283 }
284 #undef __FN__
285
286 /*
287 * Driver interface functions (dev_ops and cb_ops)
288 */
289
290 #define __FN__ "ippctl_info"
291 /*ARGSUSED*/
292 static int
293 ippctl_info(
294 dev_info_t *dip,
295 ddi_info_cmd_t cmd,
296 void *arg,
297 void **result)
298 {
299 int rc = DDI_FAILURE;
300
301 switch (cmd) {
302 case DDI_INFO_DEVT2INSTANCE:
303 *result = NULL; /* Single instance driver */
304 rc = DDI_SUCCESS;
305 break;
306 case DDI_INFO_DEVT2DEVINFO:
307 *result = (void *)ippctl_dip;
308 rc = DDI_SUCCESS;
309 break;
310 default:
311 break;
312 }
313
314 return (rc);
315 }
316 #undef __FN__
317
318 #define __FN__ "ippctl_attach"
319 static int
320 ippctl_attach(
321 dev_info_t *dip,
322 ddi_attach_cmd_t cmd)
323 {
324 switch (cmd) {
325 case DDI_ATTACH:
326 break;
327 case DDI_PM_RESUME:
328 /*FALLTHRU*/
329 case DDI_RESUME:
330 /*FALLTHRU*/
331 default:
332 return (DDI_FAILURE);
333 }
334
335 DBG0(DBG_DEVOPS, "DDI_ATTACH\n");
336
337 /*
338 * This is strictly a single instance driver.
339 */
340
341 if (ippctl_dip != NULL)
342 return (DDI_FAILURE);
343
344 /*
345 * Create minor node.
346 */
347
348 if (ddi_create_minor_node(dip, "ctl", S_IFCHR, 0,
349 DDI_PSEUDO, 0) != DDI_SUCCESS)
350 return (DDI_FAILURE);
351
352 /*
353 * No need for per-instance structure, just store vital data in
354 * globals.
355 */
356
357 ippctl_dip = dip;
358 mutex_init(&ippctl_lock, NULL, MUTEX_DRIVER, NULL);
359 ippctl_busy = B_FALSE;
360
361 return (DDI_SUCCESS);
362 }
363 #undef __FN__
364
365 #define __FN__ "ippctl_detach"
366 /*ARGSUSED*/
367 static int
368 ippctl_detach(
369 dev_info_t *dip,
370 ddi_detach_cmd_t cmd)
371 {
372 switch (cmd) {
373 case DDI_DETACH:
374 break;
375 case DDI_PM_SUSPEND:
376 /*FALLTHRU*/
377 case DDI_SUSPEND:
378 /*FALLTHRU*/
379 default:
380 return (DDI_FAILURE);
381 }
382
383 DBG0(DBG_DEVOPS, "DDI_DETACH\n");
384
385 ASSERT(dip == ippctl_dip);
386
387 ddi_remove_minor_node(dip, NULL);
388 mutex_destroy(&ippctl_lock);
389 ippctl_dip = NULL;
390
391 return (DDI_SUCCESS);
392 }
393 #undef __FN__
394
395 #define __FN__ "ippctl_open"
396 /*ARGSUSED*/
397 static int
398 ippctl_open(
399 dev_t *devp,
400 int flag,
401 int otyp,
402 cred_t *credp)
403 {
404 minor_t minor = getminor(*devp);
405 #define LIMIT 4
406
407 DBG0(DBG_CBOPS, "open\n");
408
409 /*
410 * Only allow privileged users to open our device.
411 */
412
413 if (secpolicy_net_config(credp, B_FALSE) != 0) {
414 DBG0(DBG_CBOPS, "not privileged user\n");
415 return (EPERM);
416 }
417
418 /*
419 * Sanity check other arguments.
420 */
421
422 if (minor != 0) {
423 DBG0(DBG_CBOPS, "bad minor\n");
424 return (ENXIO);
425 }
426
427 if (otyp != OTYP_CHR) {
428 DBG0(DBG_CBOPS, "bad device type\n");
429 return (EINVAL);
430 }
431
432 /*
433 * This is also a single dev_t driver.
434 */
435
436 mutex_enter(&ippctl_lock);
437 if (ippctl_busy) {
438 mutex_exit(&ippctl_lock);
439 return (EBUSY);
440 }
441 ippctl_busy = B_TRUE;
442 mutex_exit(&ippctl_lock);
443
444 /*
445 * Allocate data buffer array (starting with length LIMIT, defined
446 * at the start of this function).
447 */
448
449 ippctl_alloc(LIMIT);
450
451 DBG0(DBG_CBOPS, "success\n");
452
453 return (0);
454
455 #undef LIMIT
456 }
457 #undef __FN__
458
459 #define __FN__ "ippctl_close"
460 /*ARGSUSED*/
461 static int
462 ippctl_close(
463 dev_t dev,
464 int flag,
465 int otyp,
466 cred_t *credp)
467 {
468 minor_t minor = getminor(dev);
469
470 DBG0(DBG_CBOPS, "close\n");
471
472 ASSERT(minor == 0);
473
474 /*
475 * Free the data buffer array.
476 */
477
478 ippctl_free();
479
480 mutex_enter(&ippctl_lock);
481 ippctl_busy = B_FALSE;
482 mutex_exit(&ippctl_lock);
483
484 DBG0(DBG_CBOPS, "success\n");
485
486 return (0);
487 }
488 #undef __FN__
489
490 #define __FN__ "ippctl_ioctl"
491 static int
492 ippctl_ioctl(
493 dev_t dev,
494 int cmd,
495 intptr_t arg,
496 int mode,
497 cred_t *credp,
498 int *rvalp)
499 {
500 minor_t minor = getminor(dev);
501 char *cbuf;
502 char *dbuf;
503 size_t cbuflen;
504 size_t dbuflen;
505 size_t nextbuflen;
506 int rc;
507
508 /*
509 * Paranoia check.
510 */
511
512 if (secpolicy_net_config(credp, B_FALSE) != 0) {
513 DBG0(DBG_CBOPS, "not privileged user\n");
514 return (EPERM);
515 }
516
517 if (minor != 0) {
518 DBG0(DBG_CBOPS, "bad minor\n");
519 return (ENXIO);
520 }
521
522 switch (cmd) {
523 case IPPCTL_CMD:
524 DBG0(DBG_CBOPS, "command\n");
525
526 /*
527 * Copy in the command buffer from user space.
528 */
529
530 if ((rc = ippctl_copyin((caddr_t)arg, mode, &cbuf,
531 &cbuflen)) != 0)
532 break;
533
534 /*
535 * Execute the command.
536 */
537
538 rc = ippctl_cmd(cbuf, cbuflen, &nextbuflen);
539
540 /*
541 * Pass back the length of the first data buffer.
542 */
543
544 DBG1(DBG_CBOPS, "nextbuflen = %lu\n", nextbuflen);
545 *rvalp = nextbuflen;
546
547 /*
548 * Free the kernel copy of the command buffer.
549 */
550
551 kmem_free(cbuf, cbuflen);
552 break;
553
554 case IPPCTL_DATA:
555 DBG0(DBG_CBOPS, "data\n");
556
557 /*
558 * Grab the next data buffer from the array of pending
559 * buffers.
560 */
561
562 if ((rc = ippctl_data(&dbuf, &dbuflen, &nextbuflen)) != 0)
563 break;
564
565 /*
566 * Copy it out to user space.
567 */
568
569 rc = ippctl_copyout((caddr_t)arg, mode, dbuf, dbuflen);
570
571 /*
572 * Pass back the length of the next data buffer.
573 */
574
575 DBG1(DBG_CBOPS, "nextbuflen = %lu\n", nextbuflen);
576 *rvalp = nextbuflen;
577 break;
578
579 default:
580 DBG0(DBG_CBOPS, "unrecognized ioctl\n");
581 rc = EINVAL;
582 break;
583 }
584
585 DBG1(DBG_CBOPS, "rc = %d\n", rc);
586 return (rc);
587 }
588 #undef __FN__
589
590 /*
591 * Local functions
592 */
593
594 #define __FN__ "ippctl_copyin"
595 static int
596 ippctl_copyin(
597 caddr_t arg,
598 int mode,
599 char **kbufp,
600 size_t *kbuflenp)
601 {
602 ippctl_ioctl_t iioc;
603 caddr_t ubuf;
604 char *kbuf;
605 size_t ubuflen;
606
607 DBG0(DBG_CBOPS, "copying in ioctl structure\n");
608
609 /*
610 * Copy in the ioctl structure from user-space, converting from 32-bit
611 * as necessary.
612 */
613
614 #ifdef _MULTI_DATAMODEL
615 switch (ddi_model_convert_from(mode & FMODELS)) {
616 case DDI_MODEL_ILP32:
617 {
618 ippctl_ioctl32_t iioc32;
619
620 DBG0(DBG_CBOPS, "converting from 32-bit\n");
621
622 if (ddi_copyin(arg, (caddr_t)&iioc32,
623 sizeof (ippctl_ioctl32_t), mode) != 0)
624 return (EFAULT);
625
626 ubuf = (caddr_t)(uintptr_t)iioc32.ii32_buf;
627 ubuflen = (size_t)iioc32.ii32_buflen;
628 }
629 break;
630 case DDI_MODEL_NONE:
631 if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
632 mode) != 0)
633 return (EFAULT);
634
635 ubuf = iioc.ii_buf;
636 ubuflen = iioc.ii_buflen;
637 break;
638 default:
639 return (EFAULT);
640 }
641 #else /* _MULTI_DATAMODEL */
642 if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
643 mode) != 0)
644 return (EFAULT);
645
646 ubuf = iioc.ii_buf;
647 ubuflen = iioc.ii_buflen;
648 #endif /* _MULTI_DATAMODEL */
649
650 DBG1(DBG_CBOPS, "ubuf = 0x%p\n", (void *)ubuf);
651 DBG1(DBG_CBOPS, "ubuflen = %lu\n", ubuflen);
652
653 /*
654 * Sanity check the command buffer information.
655 */
656
657 if (ubuflen == 0 || ubuf == NULL)
658 return (EINVAL);
659 if (ubuflen > MAXUBUFLEN)
660 return (E2BIG);
661
662 /*
663 * Allocate some memory for the command buffer and copy it in.
664 */
665
666 kbuf = kmem_zalloc(ubuflen, KM_SLEEP);
667 DBG0(DBG_CBOPS, "copying in nvlist\n");
668 if (ddi_copyin(ubuf, (caddr_t)kbuf, ubuflen, mode) != 0) {
669 kmem_free(kbuf, ubuflen);
670 return (EFAULT);
671 }
672
673 *kbufp = kbuf;
674 *kbuflenp = ubuflen;
675 return (0);
676 }
677 #undef __FN__
678
679 #define __FN__ "ippctl_copyout"
680 static int
681 ippctl_copyout(
682 caddr_t arg,
683 int mode,
684 char *kbuf,
685 size_t kbuflen)
686 {
687 ippctl_ioctl_t iioc;
688 caddr_t ubuf;
689 int ubuflen;
690
691 DBG0(DBG_CBOPS, "copying out ioctl structure\n");
692
693 /*
694 * Copy in the ioctl structure from user-space, converting from 32-bit
695 * as necessary.
696 */
697
698 #ifdef _MULTI_DATAMODEL
699 switch (ddi_model_convert_from(mode & FMODELS)) {
700 case DDI_MODEL_ILP32:
701 {
702 ippctl_ioctl32_t iioc32;
703
704 if (ddi_copyin(arg, (caddr_t)&iioc32,
705 sizeof (ippctl_ioctl32_t), mode) != 0)
706 return (EFAULT);
707
708 ubuf = (caddr_t)(uintptr_t)iioc32.ii32_buf;
709 ubuflen = iioc32.ii32_buflen;
710 }
711 break;
712 case DDI_MODEL_NONE:
713 if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
714 mode) != 0)
715 return (EFAULT);
716
717 ubuf = iioc.ii_buf;
718 ubuflen = iioc.ii_buflen;
719 break;
720 default:
721 return (EFAULT);
722 }
723 #else /* _MULTI_DATAMODEL */
724 if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
725 mode) != 0)
726 return (EFAULT);
727
728 ubuf = iioc.ii_buf;
729 ubuflen = iioc.ii_buflen;
730 #endif /* _MULTI_DATAMODEL */
731
732 DBG1(DBG_CBOPS, "ubuf = 0x%p\n", (void *)ubuf);
733 DBG1(DBG_CBOPS, "ubuflen = %d\n", ubuflen);
734
735 /*
736 * Sanity check the data buffer details.
737 */
738
739 if (ubuflen == 0 || ubuf == NULL)
740 return (EINVAL);
741
742 if (ubuflen < kbuflen)
743 return (ENOSPC);
744 if (ubuflen > MAXUBUFLEN)
745 return (E2BIG);
746
747 /*
748 * Copy out the data buffer to user space.
749 */
750
751 DBG0(DBG_CBOPS, "copying out nvlist\n");
752 if (ddi_copyout((caddr_t)kbuf, ubuf, kbuflen, mode) != 0)
753 return (EFAULT);
754
755 return (0);
756 }
757 #undef __FN__
758
759 #define __FN__ "ippctl_extract_op"
760 static int
761 ippctl_extract_op(
762 nvlist_t *nvlp,
763 uint8_t *valp)
764 {
765 int rc;
766
767 /*
768 * Look-up and remove the opcode passed from libipp from the
769 * nvlist.
770 */
771
772 if ((rc = nvlist_lookup_byte(nvlp, IPPCTL_OP, valp)) != 0)
773 return (rc);
774
775 (void) nvlist_remove_all(nvlp, IPPCTL_OP);
776 return (0);
777 }
778 #undef __FN__
779
780 #define __FN__ "ippctl_extract_aname"
781 static int
782 ippctl_extract_aname(
783 nvlist_t *nvlp,
784 char **valp)
785 {
786 int rc;
787 char *ptr;
788
789 /*
790 * Look-up and remove the action name passed from libipp from the
791 * nvlist.
792 */
793
794 if ((rc = nvlist_lookup_string(nvlp, IPPCTL_ANAME, &ptr)) != 0)
795 return (rc);
796
797 *valp = kmem_alloc(strlen(ptr) + 1, KM_SLEEP);
798 (void) strcpy(*valp, ptr);
799 (void) nvlist_remove_all(nvlp, IPPCTL_ANAME);
800 return (0);
801 }
802 #undef __FN__
803
804 #define __FN__ "ippctl_extract_modname"
805 static int
806 ippctl_extract_modname(
807 nvlist_t *nvlp,
808 char **valp)
809 {
810 int rc;
811 char *ptr;
812
813 /*
814 * Look-up and remove the module name passed from libipp from the
815 * nvlist.
816 */
817
818 if ((rc = nvlist_lookup_string(nvlp, IPPCTL_MODNAME, &ptr)) != 0)
819 return (rc);
820
821 *valp = kmem_alloc(strlen(ptr) + 1, KM_SLEEP);
822 (void) strcpy(*valp, ptr);
823 (void) nvlist_remove_all(nvlp, IPPCTL_MODNAME);
824 return (0);
825 }
826 #undef __FN__
827
828 #define __FN__ "ippctl_attach_modname"
829 static int
830 ippctl_attach_modname(
831 nvlist_t *nvlp,
832 char *modname)
833 {
834 /*
835 * Add a module name to an nvlist for passing back to user
836 * space.
837 */
838
839 return (nvlist_add_string(nvlp, IPPCTL_MODNAME, modname));
840 }
841 #undef __FN__
842
843 #define __FN__ "ippctl_attach_modname_array"
844 static int
845 ippctl_attach_modname_array(
846 nvlist_t *nvlp,
847 char **modname_array,
848 int nelt)
849 {
850 /*
851 * Add a module name array to an nvlist for passing back to user
852 * space.
853 */
854
855 return (nvlist_add_string_array(nvlp, IPPCTL_MODNAME_ARRAY,
856 modname_array, nelt));
857 }
858 #undef __FN__
859
860 #define __FN__ "ippctl_attach_aname_array"
861 static int
862 ippctl_attach_aname_array(
863 nvlist_t *nvlp,
864 char **aname_array,
865 int nelt)
866 {
867 /*
868 * Add an action name array to an nvlist for passing back to user
869 * space.
870 */
871
872 return (nvlist_add_string_array(nvlp, IPPCTL_ANAME_ARRAY,
873 aname_array, nelt));
874 }
875 #undef __FN__
876
877 #define __FN__ "ippctl_extract_flags"
878 static int
879 ippctl_extract_flags(
880 nvlist_t *nvlp,
881 ipp_flags_t *valp)
882 {
883 int rc;
884
885 /*
886 * Look-up and remove the flags passed from libipp from the
887 * nvlist.
888 */
889
890 if ((rc = nvlist_lookup_uint32(nvlp, IPPCTL_FLAGS,
891 (uint32_t *)valp)) != 0)
892 return (rc);
893
894 (void) nvlist_remove_all(nvlp, IPPCTL_FLAGS);
895 return (0);
896 }
897 #undef __FN__
898
899 #define __FN__ "ippctl_cmd"
900 static int
901 ippctl_cmd(
902 char *cbuf,
903 size_t cbuflen,
904 size_t *nextbuflenp)
905 {
906 nvlist_t *nvlp = NULL;
907 int rc;
908 char *aname = NULL;
909 char *modname = NULL;
910 ipp_flags_t flags;
911 uint8_t op;
912
913 /*
914 * Start a new command cycle by flushing any previous data buffers.
915 */
916
917 ippctl_flush();
918 *nextbuflenp = 0;
919
920 /*
921 * Unpack the nvlist from the command buffer.
922 */
923
924 if ((rc = nvlist_unpack(cbuf, cbuflen, &nvlp, KM_SLEEP)) != 0)
925 return (rc);
926
927 /*
928 * Extract the opcode to find out what we should do.
929 */
930
931 if ((rc = ippctl_extract_op(nvlp, &op)) != 0) {
932 nvlist_free(nvlp);
933 return (rc);
934 }
935
936 switch (op) {
937 case IPPCTL_OP_ACTION_CREATE:
938 /*
939 * Create a new action.
940 */
941
942 DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_CREATE\n");
943
944 /*
945 * Extract the module name, action name and flags from the
946 * nvlist.
947 */
948
949 if ((rc = ippctl_extract_modname(nvlp, &modname)) != 0) {
950 nvlist_free(nvlp);
951 return (rc);
952 }
953
954 if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
955 FREE_TEXT(modname);
956 nvlist_free(nvlp);
957 return (rc);
958 }
959
960 if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
961 FREE_TEXT(aname);
962 FREE_TEXT(modname);
963 nvlist_free(nvlp);
964 return (rc);
965 }
966
967
968 rc = ippctl_action_create(modname, aname, nvlp, flags);
969 break;
970
971 case IPPCTL_OP_ACTION_MODIFY:
972
973 /*
974 * Modify an existing action.
975 */
976
977 DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_MODIFY\n");
978
979 /*
980 * Extract the action name and flags from the nvlist.
981 */
982
983 if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
984 nvlist_free(nvlp);
985 return (rc);
986 }
987
988 if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
989 FREE_TEXT(aname);
990 nvlist_free(nvlp);
991 return (rc);
992 }
993
994 rc = ippctl_action_modify(aname, nvlp, flags);
995 break;
996
997 case IPPCTL_OP_ACTION_DESTROY:
998
999 /*
1000 * Destroy an action.
1001 */
1002
1003 DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_DESTROY\n");
1004
1005 /*
1006 * Extract the action name and flags from the nvlist.
1007 */
1008
1009 if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
1010 nvlist_free(nvlp);
1011 return (rc);
1012 }
1013
1014 if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
1015 FREE_TEXT(aname);
1016 nvlist_free(nvlp);
1017 return (rc);
1018 }
1019
1020 nvlist_free(nvlp);
1021 rc = ippctl_action_destroy(aname, flags);
1022 break;
1023
1024 case IPPCTL_OP_ACTION_INFO:
1025
1026 /*
1027 * Retrive the configuration of an action.
1028 */
1029
1030 DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_INFO\n");
1031
1032 /*
1033 * Extract the action name and flags from the nvlist.
1034 */
1035
1036 if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
1037 nvlist_free(nvlp);
1038 return (rc);
1039 }
1040
1041 if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
1042 nvlist_free(nvlp);
1043 FREE_TEXT(aname);
1044 return (rc);
1045 }
1046
1047 nvlist_free(nvlp);
1048 rc = ippctl_action_info(aname, flags);
1049 break;
1050
1051 case IPPCTL_OP_ACTION_MOD:
1052
1053 /*
1054 * Find the module that implements a given action.
1055 */
1056
1057 DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_MOD\n");
1058
1059 /*
1060 * Extract the action name from the nvlist.
1061 */
1062
1063 if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
1064 nvlist_free(nvlp);
1065 return (rc);
1066 }
1067
1068 nvlist_free(nvlp);
1069 rc = ippctl_action_mod(aname);
1070 break;
1071
1072 case IPPCTL_OP_LIST_MODS:
1073
1074 /*
1075 * List all the modules.
1076 */
1077
1078 DBG0(DBG_CBOPS, "op = IPPCTL_OP_LIST_MODS\n");
1079
1080 nvlist_free(nvlp);
1081 rc = ippctl_list_mods();
1082 break;
1083
1084 case IPPCTL_OP_MOD_LIST_ACTIONS:
1085
1086 /*
1087 * List all the actions for a given module.
1088 */
1089
1090 DBG0(DBG_CBOPS, "op = IPPCTL_OP_LIST_MODS\n");
1091
1092 if ((rc = ippctl_extract_modname(nvlp, &modname)) != 0) {
1093 nvlist_free(nvlp);
1094 return (rc);
1095 }
1096
1097 nvlist_free(nvlp);
1098 rc = ippctl_mod_list_actions(modname);
1099 break;
1100
1101 default:
1102
1103 /*
1104 * Unrecognized opcode.
1105 */
1106
1107 nvlist_free(nvlp);
1108 rc = EINVAL;
1109 break;
1110 }
1111
1112 /*
1113 * The length of buffer that we need to notify back to libipp with
1114 * the command ioctl's return is the length of the first data buffer
1115 * in the array. We only expact to pass back data buffers if the
1116 * operation succeeds (NOTE: this does not mean the kernel call has
1117 * to succeed, merely that we successfully issued it and processed
1118 * the results).
1119 */
1120
1121 if (rc == 0)
1122 *nextbuflenp = ippctl_array[0].buflen;
1123
1124 return (rc);
1125 }
1126 #undef __FN__
1127
1128 #define __FN__ "ippctl_action_create"
1129 static int
1130 ippctl_action_create(
1131 char *modname,
1132 char *aname,
1133 nvlist_t *nvlp,
1134 ipp_flags_t flags)
1135 {
1136 int ipp_rc;
1137 int rc;
1138 ipp_mod_id_t mid;
1139 ipp_action_id_t aid;
1140
1141 /*
1142 * Look up the module id from the name and create the new
1143 * action.
1144 */
1145
1146 mid = ipp_mod_lookup(modname);
1147 FREE_TEXT(modname);
1148
1149 ipp_rc = ipp_action_create(mid, aname, &nvlp, flags, &aid);
1150 FREE_TEXT(aname);
1151
1152 /*
1153 * Add an nvlist containing the kernel return code to the
1154 * set of nvlists to pass back to libipp.
1155 */
1156
1157 if ((rc = ippctl_set_rc(ipp_rc)) != 0) {
1158 if (nvlp != NULL) {
1159 nvlist_free(nvlp);
1160 if (ipp_action_destroy(aid, 0) != 0) {
1161 cmn_err(CE_PANIC,
1162 "ippctl: unrecoverable error (aid = %d)",
1163 aid);
1164 /*NOTREACHED*/
1165 }
1166 }
1167 return (rc);
1168 }
1169
1170 /*
1171 * If the module passed back an nvlist, add this as
1172 * well.
1173 */
1174
1175 if (nvlp != NULL) {
1176 rc = ippctl_callback(nvlp, NULL);
1177 nvlist_free(nvlp);
1178 } else
1179 rc = 0;
1180
1181 return (rc);
1182 }
1183 #undef __FN__
1184
1185 #define __FN__ "ippctl_action_destroy"
1186 static int
1187 ippctl_action_destroy(
1188 char *aname,
1189 ipp_flags_t flags)
1190 {
1191 ipp_action_id_t aid;
1192 int ipp_rc;
1193 int rc;
1194
1195 /*
1196 * Look up the action id and destroy the action.
1197 */
1198
1199 aid = ipp_action_lookup(aname);
1200 FREE_TEXT(aname);
1201
1202 ipp_rc = ipp_action_destroy(aid, flags);
1203
1204 /*
1205 * Add an nvlist containing the kernel return code to the
1206 * set of nvlists to pass back to libipp.
1207 */
1208
1209 if ((rc = ippctl_set_rc(ipp_rc)) != 0)
1210 return (rc);
1211
1212 /*
1213 * There's no more information to pass back.
1214 */
1215
1216 return (0);
1217 }
1218 #undef __FN__
1219
1220 #define __FN__ "ippctl_action_modify"
1221 static int
1222 ippctl_action_modify(
1223 char *aname,
1224 nvlist_t *nvlp,
1225 ipp_flags_t flags)
1226 {
1227 ipp_action_id_t aid;
1228 int ipp_rc;
1229 int rc;
1230
1231 /*
1232 * Look up the action id and modify the action.
1233 */
1234
1235 aid = ipp_action_lookup(aname);
1236 FREE_TEXT(aname);
1237
1238 ipp_rc = ipp_action_modify(aid, &nvlp, flags);
1239
1240 /*
1241 * Add an nvlist containing the kernel return code to the
1242 * set of nvlists to pass back to libipp.
1243 */
1244
1245 if ((rc = ippctl_set_rc(ipp_rc)) != 0) {
1246 nvlist_free(nvlp);
1247 return (rc);
1248 }
1249
1250 /*
1251 * If the module passed back an nvlist, add this as
1252 * well.
1253 */
1254
1255 if (nvlp != NULL) {
1256 rc = ippctl_callback(nvlp, NULL);
1257 nvlist_free(nvlp);
1258 } else
1259 rc = 0;
1260
1261 return (rc);
1262 }
1263 #undef __FN__
1264
1265 #define __FN__ "ippctl_action_info"
1266 static int
1267 ippctl_action_info(
1268 char *aname,
1269 ipp_flags_t flags)
1270 {
1271 ipp_action_id_t aid;
1272 int ipp_rc;
1273 int rc;
1274
1275 /*
1276 * Look up the action and call the information retrieval
1277 * entry point.
1278 *
1279 * NOTE: The callback function that is passed in packs and
1280 * stores each of the nvlists it is called with in the array
1281 * that will be passed back to libipp.
1282 */
1283
1284 aid = ipp_action_lookup(aname);
1285 FREE_TEXT(aname);
1286
1287 ipp_rc = ipp_action_info(aid, ippctl_callback, NULL, flags);
1288
1289 /*
1290 * Add an nvlist containing the kernel return code to the
1291 * set of nvlists to pass back to libipp.
1292 */
1293
1294 if ((rc = ippctl_set_rc(ipp_rc)) != 0)
1295 return (rc);
1296
1297 /*
1298 * There's no more information to pass back.
1299 */
1300
1301 return (0);
1302 }
1303 #undef __FN__
1304
1305 #define __FN__ "ippctl_action_mod"
1306 static int
1307 ippctl_action_mod(
1308 char *aname)
1309 {
1310 ipp_mod_id_t mid;
1311 ipp_action_id_t aid;
1312 char *modname;
1313 nvlist_t *nvlp;
1314 int ipp_rc;
1315 int rc;
1316
1317 /*
1318 * Look up the action id and get the id of the module that
1319 * implements the action. If that succeeds then look up the
1320 * name of the module.
1321 */
1322
1323 aid = ipp_action_lookup(aname);
1324 FREE_TEXT(aname);
1325
1326 if ((ipp_rc = ipp_action_mod(aid, &mid)) == 0)
1327 ipp_rc = ipp_mod_name(mid, &modname);
1328
1329 /*
1330 * Add an nvlist containing the kernel return code to the
1331 * set of nvlists to pass back to libipp.
1332 */
1333
1334 if ((rc = ippctl_set_rc(ipp_rc)) != 0)
1335 return (rc);
1336
1337 /*
1338 * If everything succeeded add an nvlist containing the
1339 * module name to the set of nvlists to pass back to libipp.
1340 */
1341
1342 if (ipp_rc == 0) {
1343 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_SLEEP)) != 0)
1344 return (rc);
1345
1346 if ((rc = ippctl_attach_modname(nvlp, modname)) != 0) {
1347 nvlist_free(nvlp);
1348 return (rc);
1349 }
1350
1351 FREE_TEXT(modname);
1352
1353 rc = ippctl_callback(nvlp, NULL);
1354 nvlist_free(nvlp);
1355 } else
1356 rc = 0;
1357
1358 return (rc);
1359 }
1360 #undef __FN__
1361
1362 #define __FN__ "ippctl_list_mods"
1363 static int
1364 ippctl_list_mods(
1365 void)
1366 {
1367 nvlist_t *nvlp;
1368 int ipp_rc;
1369 int rc = 0;
1370 ipp_mod_id_t *mid_array;
1371 char **modname_array = NULL;
1372 int nelt;
1373 int length;
1374 int i;
1375
1376 /*
1377 * Get a list of all the module ids. If that succeeds,
1378 * translate the ids into names.
1379 *
1380 * NOTE: This translation may fail if a module is
1381 * unloaded during this operation. If this occurs, EAGAIN
1382 * will be passed back to libipp note that a transient
1383 * problem occured.
1384 */
1385
1386 if ((ipp_rc = ipp_list_mods(&mid_array, &nelt)) == 0) {
1387
1388 /*
1389 * It is possible that there are no modules
1390 * registered.
1391 */
1392
1393 if (nelt > 0) {
1394 length = nelt * sizeof (char *);
1395 modname_array = kmem_zalloc(length, KM_SLEEP);
1396
1397 for (i = 0; i < nelt; i++) {
1398 if (ipp_mod_name(mid_array[i],
1399 &modname_array[i]) != 0) {
1400 kmem_free(mid_array, nelt *
1401 sizeof (ipp_mod_id_t));
1402 FREE_TEXT_ARRAY(modname_array, nelt);
1403 ipp_rc = EAGAIN;
1404 goto done;
1405 }
1406 }
1407
1408 kmem_free(mid_array, nelt * sizeof (ipp_mod_id_t));
1409
1410 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME,
1411 KM_SLEEP)) != 0) {
1412 FREE_TEXT_ARRAY(modname_array, nelt);
1413 return (rc);
1414 }
1415
1416 if ((rc = ippctl_attach_modname_array(nvlp,
1417 modname_array, nelt)) != 0) {
1418 FREE_TEXT_ARRAY(modname_array, nelt);
1419 nvlist_free(nvlp);
1420 return (rc);
1421 }
1422
1423 FREE_TEXT_ARRAY(modname_array, nelt);
1424
1425 if ((rc = ippctl_callback(nvlp, NULL)) != 0) {
1426 nvlist_free(nvlp);
1427 return (rc);
1428 }
1429
1430 nvlist_free(nvlp);
1431 }
1432 }
1433
1434 done:
1435 /*
1436 * Add an nvlist containing the kernel return code to the
1437 * set of nvlists to pass back to libipp.
1438 */
1439
1440 if ((rc = ippctl_set_rc(ipp_rc)) != 0)
1441 return (rc);
1442
1443 return (0);
1444 }
1445 #undef __FN__
1446
1447 #define __FN__ "ippctl_mod_list_actions"
1448 static int
1449 ippctl_mod_list_actions(
1450 char *modname)
1451 {
1452 ipp_mod_id_t mid;
1453 nvlist_t *nvlp;
1454 int ipp_rc;
1455 int rc = 0;
1456 ipp_action_id_t *aid_array;
1457 char **aname_array = NULL;
1458 int nelt;
1459 int length;
1460 int i;
1461
1462 /*
1463 * Get the module id.
1464 */
1465
1466 mid = ipp_mod_lookup(modname);
1467 FREE_TEXT(modname);
1468
1469 /*
1470 * Get a list of all the action ids for the module. If that succeeds,
1471 * translate the ids into names.
1472 *
1473 * NOTE: This translation may fail if an action is
1474 * destroyed during this operation. If this occurs, EAGAIN
1475 * will be passed back to libipp note that a transient
1476 * problem occured.
1477 */
1478
1479 if ((ipp_rc = ipp_mod_list_actions(mid, &aid_array, &nelt)) == 0) {
1480
1481 /*
1482 * It is possible that there are no actions defined.
1483 * (This is unlikely though as the module would normally
1484 * be auto-unloaded fairly quickly)
1485 */
1486
1487 if (nelt > 0) {
1488 length = nelt * sizeof (char *);
1489 aname_array = kmem_zalloc(length, KM_SLEEP);
1490
1491 for (i = 0; i < nelt; i++) {
1492 if (ipp_action_name(aid_array[i],
1493 &aname_array[i]) != 0) {
1494 kmem_free(aid_array, nelt *
1495 sizeof (ipp_action_id_t));
1496 FREE_TEXT_ARRAY(aname_array, nelt);
1497 ipp_rc = EAGAIN;
1498 goto done;
1499 }
1500 }
1501
1502 kmem_free(aid_array, nelt * sizeof (ipp_action_id_t));
1503
1504 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME,
1505 KM_SLEEP)) != 0) {
1506 FREE_TEXT_ARRAY(aname_array, nelt);
1507 return (rc);
1508 }
1509
1510 if ((rc = ippctl_attach_aname_array(nvlp, aname_array,
1511 nelt)) != 0) {
1512 FREE_TEXT_ARRAY(aname_array, nelt);
1513 nvlist_free(nvlp);
1514 return (rc);
1515 }
1516
1517 FREE_TEXT_ARRAY(aname_array, nelt);
1518
1519 if ((rc = ippctl_callback(nvlp, NULL)) != 0) {
1520 nvlist_free(nvlp);
1521 return (rc);
1522 }
1523
1524 nvlist_free(nvlp);
1525 }
1526 }
1527
1528 done:
1529 /*
1530 * Add an nvlist containing the kernel return code to the
1531 * set of nvlists to pass back to libipp.
1532 */
1533
1534 if ((rc = ippctl_set_rc(ipp_rc)) != 0)
1535 return (rc);
1536
1537 return (0);
1538 }
1539 #undef __FN__
1540
1541 #define __FN__ "ippctl_data"
1542 static int
1543 ippctl_data(
1544 char **dbufp,
1545 size_t *dbuflenp,
1546 size_t *nextbuflenp)
1547 {
1548 int i;
1549
1550 DBG0(DBG_CBOPS, "called\n");
1551
1552 /*
1553 * Get the next data buffer from the array by looking at the
1554 * 'read index'. If this is the same as the 'write index' then
1555 * there's no more buffers in the array.
1556 */
1557
1558 i = ippctl_rindex;
1559 if (i == ippctl_windex)
1560 return (ENOENT);
1561
1562 /*
1563 * Extract the buffer details. It is a pre-packed nvlist.
1564 */
1565
1566 *dbufp = ippctl_array[i].buf;
1567 *dbuflenp = ippctl_array[i].buflen;
1568
1569 DBG2(DBG_CBOPS, "accessing nvlist[%d], length %lu\n", i, *dbuflenp);
1570 ASSERT(*dbufp != NULL);
1571
1572 /*
1573 * Advance the 'read index' and check if there's another buffer.
1574 * If there is then we need to pass back its length to libipp so that
1575 * another data ioctl will be issued.
1576 */
1577
1578 i++;
1579 if (i < ippctl_windex)
1580 *nextbuflenp = ippctl_array[i].buflen;
1581 else
1582 *nextbuflenp = 0;
1583
1584 ippctl_rindex = i;
1585 return (0);
1586 }
1587 #undef __FN__
1588
1589 #define __FN__ "ippctl_flush"
1590 static void
1591 ippctl_flush(
1592 void)
1593 {
1594 int i;
1595 char *buf;
1596 size_t buflen;
1597
1598 /*
1599 * Free any buffers left in the array.
1600 */
1601
1602 for (i = 0; i < ippctl_limit; i++) {
1603 if ((buflen = ippctl_array[i].buflen) > 0) {
1604 buf = ippctl_array[i].buf;
1605 ASSERT(buf != NULL);
1606 kmem_free(buf, buflen);
1607 }
1608 }
1609
1610 /*
1611 * NULL all the entries.
1612 */
1613
1614 bzero(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));
1615
1616 /*
1617 * Reset the indexes.
1618 */
1619
1620 ippctl_rindex = 0;
1621 ippctl_windex = 1;
1622 }
1623 #undef __FN__
1624
1625 #define __FN__ "ippctl_add_nvlist"
1626 static int
1627 ippctl_add_nvlist(
1628 nvlist_t *nvlp,
1629 int i)
1630 {
1631 char *buf;
1632 size_t buflen;
1633 int rc;
1634
1635 /*
1636 * NULL the buffer pointer so that a buffer is automatically
1637 * allocated for us.
1638 */
1639
1640 buf = NULL;
1641
1642 /*
1643 * Pack the nvlist and get back the buffer pointer and length.
1644 */
1645
1646 if ((rc = nvlist_pack(nvlp, &buf, &buflen, NV_ENCODE_NATIVE,
1647 KM_SLEEP)) != 0) {
1648 ippctl_array[i].buf = NULL;
1649 ippctl_array[i].buflen = 0;
1650 return (rc);
1651 }
1652
1653 DBG2(DBG_CBOPS, "added nvlist[%d]: length %lu\n", i, buflen);
1654
1655 /*
1656 * Store the pointer an length in the array at the given index.
1657 */
1658
1659 ippctl_array[i].buf = buf;
1660 ippctl_array[i].buflen = buflen;
1661
1662 return (0);
1663 }
1664 #undef __FN__
1665
1666 #define __FN__ "ippctl_callback"
1667 /*ARGSUSED*/
1668 static int
1669 ippctl_callback(
1670 nvlist_t *nvlp,
1671 void *arg)
1672 {
1673 int i;
1674 int rc;
1675
1676 /*
1677 * Check the 'write index' to see if there's space in the array for
1678 * a new entry.
1679 */
1680
1681 i = ippctl_windex;
1682 ASSERT(i != 0);
1683
1684 /*
1685 * If there's no space, re-allocate the array (see comments in
1686 * ippctl_realloc() for details).
1687 */
1688
1689 if (i == ippctl_limit)
1690 ippctl_realloc();
1691
1692 /*
1693 * Add the nvlist to the array.
1694 */
1695
1696 if ((rc = ippctl_add_nvlist(nvlp, i)) == 0)
1697 ippctl_windex++;
1698
1699 return (rc);
1700 }
1701 #undef __FN__
1702
1703 #define __FN__ "ippctl_set_rc"
1704 static int
1705 ippctl_set_rc(
1706 int val)
1707 {
1708 nvlist_t *nvlp;
1709 int rc;
1710
1711 /*
1712 * Create an nvlist to store the return code,
1713 */
1714
1715 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_SLEEP)) != 0)
1716 return (ENOMEM);
1717
1718 if ((rc = nvlist_add_int32(nvlp, IPPCTL_RC, val)) != 0) {
1719 nvlist_free(nvlp);
1720 return (rc);
1721 }
1722
1723 /*
1724 * Add it at the beginning of the array.
1725 */
1726
1727 rc = ippctl_add_nvlist(nvlp, 0);
1728
1729 nvlist_free(nvlp);
1730 return (rc);
1731 }
1732 #undef __FN__
1733
1734 #define __FN__ "ippctl_alloc"
1735 static void
1736 ippctl_alloc(
1737 int limit)
1738 {
1739 /*
1740 * Allocate the data buffer array and initialize the indexes.
1741 */
1742
1743 ippctl_array = kmem_zalloc(limit * sizeof (ippctl_buf_t), KM_SLEEP);
1744 ippctl_limit = limit;
1745 ippctl_rindex = 0;
1746 ippctl_windex = 1;
1747 }
1748 #undef __FN__
1749
1750 #define __FN__ "ippctl_realloc"
1751 static void
1752 ippctl_realloc(
1753 void)
1754 {
1755 ippctl_buf_t *array;
1756 int limit;
1757 int i;
1758
1759 /*
1760 * Allocate a new array twice the size of the old one.
1761 */
1762
1763 limit = ippctl_limit << 1;
1764 array = kmem_zalloc(limit * sizeof (ippctl_buf_t), KM_SLEEP);
1765
1766 /*
1767 * Copy across the information from the old array into the new one.
1768 */
1769
1770 for (i = 0; i < ippctl_limit; i++)
1771 array[i] = ippctl_array[i];
1772
1773 /*
1774 * Free the old array.
1775 */
1776
1777 kmem_free(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));
1778
1779 ippctl_array = array;
1780 ippctl_limit = limit;
1781 }
1782 #undef __FN__
1783
1784 #define __FN__ "ippctl_free"
1785 static void
1786 ippctl_free(
1787 void)
1788 {
1789 /*
1790 * Flush the array prior to freeing it to make sure no buffers are
1791 * leaked.
1792 */
1793
1794 ippctl_flush();
1795
1796 /*
1797 * Free the array.
1798 */
1799
1800 kmem_free(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));
1801 ippctl_array = NULL;
1802 ippctl_limit = -1;
1803 ippctl_rindex = -1;
1804 ippctl_windex = -1;
1805 }
1806 #undef __FN__
1807
1808 #ifdef IPPCTL_DEBUG
1809 static void
1810 ippctl_debug(
1811 uint64_t type,
1812 char *fn,
1813 char *fmt,
1814 ...)
1815 {
1816 char buf[255];
1817 va_list adx;
1818
1819 if ((type & ippctl_debug_flags) == 0)
1820 return;
1821
1822 mutex_enter(debug_mutex);
1823 va_start(adx, fmt);
1824 (void) vsnprintf(buf, 255, fmt, adx);
1825 va_end(adx);
1826
1827 printf("%s: %s", fn, buf);
1828 mutex_exit(debug_mutex);
1829 }
1830 #endif /* IPPCTL_DBG */