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 #include <sys/types.h>
27 #include <sys/systm.h>
28 #include <sys/socket.h>
29 #include <netinet/in.h>
30 #include <sys/modctl.h>
31 #include <sys/sunddi.h>
32 #include <ipp/ipp.h>
33 #include <ipp/ipp_config.h>
34 #include <inet/common.h>
35 #include <ipp/dscpmk/dscpmk_impl.h>
36
37 #define D_SM_COMMENT "IPP dscpmk marker module"
38
39 /* DDI file for dscpmk ipp module */
40
41 /* default dscp map - dscp unchanged */
42 uint8_t default_dscp_map[DSCPMK_ARRAY_COUNT] = {
43 0, 1, 2, 3,
44 4, 5, 6, 7,
45 8, 9, 10, 11,
46 12, 13, 14, 15,
47 16, 17, 18, 19,
48 20, 21, 22, 23,
49 24, 25, 26, 27,
50 28, 29, 30, 31,
51 32, 33, 34, 35,
52 36, 37, 38, 39,
53 40, 41, 42, 43,
54 44, 45, 46, 47,
55 48, 49, 50, 51,
56 52, 53, 54, 55,
57 56, 57, 58, 59,
58 60, 61, 62, 63
59 };
60
61 static int dscpmk_create_action(ipp_action_id_t, nvlist_t **, ipp_flags_t);
62 static int dscpmk_modify_action(ipp_action_id_t, nvlist_t **, ipp_flags_t);
63 static int dscpmk_destroy_action(ipp_action_id_t, ipp_flags_t);
64 static int dscpmk_info(ipp_action_id_t, int (*)(nvlist_t *, void *), void *,
65 ipp_flags_t);
66 static int dscpmk_invoke_action(ipp_action_id_t, ipp_packet_t *);
67
68 /* Creating and updating summary stats */
69 static int dscpmk_summ_statinit(ipp_action_id_t, dscpmk_data_t *);
70 static int dscpmk_update_stats(ipp_stat_t *, void *, int);
71
72 /* Creating and updating per-dscp stats */
73 static int dscpmk_det_statinit(ipp_action_id_t, dscpmk_data_t *, int);
74 static int dscpmk_update_det_stats(ipp_stat_t *, void *, int);
75
76 /* Entry points for this IPP module */
77 ipp_ops_t dscpmk_ops = {
78 IPPO_REV,
79 dscpmk_create_action, /* ippo_action_create */
80 dscpmk_modify_action, /* ippo_action_modify */
81 dscpmk_destroy_action, /* ippo_action_destroy */
82 dscpmk_info, /* ippo_action_info */
83 dscpmk_invoke_action /* ippo_action_invoke */
84 };
85
86 extern struct mod_ops mod_ippops;
87
88 /*
89 * Module linkage information for the kernel.
90 */
91 static struct modlipp modlipp = {
92 &mod_ippops,
93 D_SM_COMMENT,
94 &dscpmk_ops
95 };
96
97 static struct modlinkage modlinkage = {
98 MODREV_1,
99 (void *)&modlipp,
100 NULL
101 };
102
103
104 int
105 _init(void)
106 {
107 return (mod_install(&modlinkage));
108 }
109
110 int
111 _fini(void)
112 {
113 return (mod_remove(&modlinkage));
114 }
115
116 int
117 _info(struct modinfo *modinfop)
118 {
119 return (mod_info(&modlinkage, modinfop));
120 }
121
122 static int
123 dscpmk_create_action(ipp_action_id_t aid, nvlist_t **nvlpp, ipp_flags_t flags)
124 {
125 nvlist_t *nvlp;
126 dscpmk_data_t *dscpmk_data;
127 char *next_action;
128 int err, cnt;
129 int32_t *tbl;
130 uint_t nelem = DSCPMK_ARRAY_COUNT;
131 uint32_t bstats;
132
133 ASSERT((nvlpp != NULL) && (*nvlpp != NULL));
134
135 nvlp = *nvlpp;
136 *nvlpp = NULL; /* nvlist should be NULL on return */
137
138 if ((dscpmk_data = kmem_zalloc(DSCPMK_DATA_SZ, KM_NOSLEEP)) == NULL) {
139 nvlist_free(nvlp);
140 return (ENOMEM);
141 }
142
143 /* parse next action name */
144 if ((err = nvlist_lookup_string(nvlp, DSCPMK_NEXT_ACTION_NAME,
145 &next_action)) != 0) {
146 nvlist_free(nvlp);
147 dscpmk0dbg(("dscpmk_create_action: invalid config, " \
148 "next_action name missing\n"));
149 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
150 return (err);
151 }
152
153 if ((dscpmk_data->next_action = ipp_action_lookup(next_action))
154 == IPP_ACTION_INVAL) {
155 nvlist_free(nvlp);
156 dscpmk0dbg(("dscpmk_create_action: next_action "\
157 "invalid\n"));
158 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
159 return (EINVAL);
160 }
161
162 /* Fill in the default value */
163 bcopy(default_dscp_map, dscpmk_data->dscp_map,
164 sizeof (default_dscp_map));
165 /*
166 * parse dscp_map, if present. Note that the module gets
167 * the entire array with unchanged entries marked with -1.
168 */
169 if ((err = nvlist_lookup_int32_array(nvlp, DSCPMK_DSCP_MAP,
170 &tbl, &nelem)) == 0) {
171 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
172 if ((tbl[cnt] != DSCPMK_UNCHANGED_DSCP) && (tbl[cnt] !=
173 dscpmk_data->dscp_map[cnt])) {
174 dscpmk_data->dscp_map[cnt] = tbl[cnt];
175 }
176 }
177 }
178
179
180 /* parse summary_stats boolean */
181 if ((err = nvlist_lookup_uint32(nvlp, IPP_ACTION_STATS_ENABLE, &bstats))
182 != 0) {
183 dscpmk_data->summary_stats = B_FALSE;
184 } else {
185 dscpmk_data->summary_stats = (bstats != 0) ? B_TRUE : B_FALSE;
186 /* If stats is needed, initialize the stats structure */
187 if (dscpmk_data->summary_stats) {
188 if ((err = dscpmk_summ_statinit(aid, dscpmk_data))
189 != 0) {
190 nvlist_free(nvlp);
191 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
192 return (err);
193 }
194 }
195 }
196
197 /*
198 * Initialize per-dscp stats; B_FALSE in present indicates a dscp
199 * with this value (count) is not present in the map.
200 */
201 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
202 dscpmk_data->dscp_stats[cnt].present = B_FALSE;
203 dscpmk_data->dscp_stats[cnt].npackets = 0;
204 }
205
206 /* parse detailed_stats boolean */
207 if ((err = nvlist_lookup_uint32(nvlp, DSCPMK_DETAILED_STATS, &bstats))
208 != 0) {
209 dscpmk_data->detailed_stats = B_FALSE;
210 } else {
211 dscpmk_data->detailed_stats = (bstats != 0) ? B_TRUE : B_FALSE;
212 /* If stats is needed, initialize the stats structure */
213 if (dscpmk_data->detailed_stats) {
214 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
215 int val = dscpmk_data->dscp_map[cnt];
216 if (dscpmk_data->dscp_stats[val].present) {
217 continue;
218 }
219 dscpmk_data->dscp_stats[val].present = B_TRUE;
220 if ((err = dscpmk_det_statinit(aid, dscpmk_data,
221 val)) != 0) {
222 nvlist_free(nvlp);
223 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
224 return (err);
225 }
226 }
227 }
228 }
229
230 /* Free the nvlist */
231 nvlist_free(nvlp);
232
233 /* set action chain reference */
234 if ((err = ipp_action_ref(aid, dscpmk_data->next_action, flags)) != 0) {
235 dscpmk0dbg(("dscpmk_create_action: ipp_action_ref " \
236 "returned with error %d\n", err));
237 if (dscpmk_data->summary_stats) {
238 ipp_stat_destroy(dscpmk_data->stats);
239 }
240 if (dscpmk_data->detailed_stats) {
241 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
242 if (dscpmk_data->dscp_stats[cnt].present) {
243 ipp_stat_destroy(
244 dscpmk_data->dscp_stats[cnt].stats);
245 }
246 }
247 }
248 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
249 return (err);
250 }
251
252 ipp_action_set_ptr(aid, (void *)dscpmk_data);
253 return (0);
254 }
255
256 static int
257 dscpmk_modify_action(ipp_action_id_t aid, nvlist_t **nvlpp, ipp_flags_t flags)
258 {
259 nvlist_t *nvlp;
260 int err = 0, cnt;
261 uint8_t config_type;
262 char *next_action_name;
263 uint32_t bstats;
264 uint_t nelem = DSCPMK_ARRAY_COUNT;
265 int32_t *tbl;
266 ipp_action_id_t next_action;
267 dscpmk_data_t *dscpmk_data;
268
269 ASSERT((nvlpp != NULL) && (*nvlpp != NULL));
270
271 nvlp = *nvlpp;
272 *nvlpp = NULL; /* nvlist should be NULL when this returns */
273
274 if ((err = nvlist_lookup_byte(nvlp, IPP_CONFIG_TYPE, &config_type))
275 != 0) {
276 nvlist_free(nvlp);
277 dscpmk0dbg(("dscpmk_modify_action: invalid cfg. type\n"));
278 return (err);
279 }
280
281 if (config_type != IPP_SET) {
282 nvlist_free(nvlp);
283 dscpmk0dbg(("dscpmk_modify_action: invalid cfg. type " \
284 "%d\n", config_type));
285 return (EINVAL);
286 }
287
288 dscpmk_data = (dscpmk_data_t *)ipp_action_get_ptr(aid);
289 ASSERT(dscpmk_data != NULL);
290
291 /* parse next action name, if present */
292 if ((err = nvlist_lookup_string(nvlp, DSCPMK_NEXT_ACTION_NAME,
293 &next_action_name)) == 0) {
294 /* lookup action name to get action id */
295 if ((next_action = ipp_action_lookup(next_action_name))
296 == IPP_ACTION_INVAL) {
297 nvlist_free(nvlp);
298 dscpmk0dbg(("dscpmk_modify_action: next_action "\
299 "invalid\n"));
300 return (EINVAL);
301 }
302 /* reference new action */
303 if ((err = ipp_action_ref(aid, next_action, flags)) != 0) {
304 nvlist_free(nvlp);
305 dscpmk0dbg(("dscpmk_modify_action: ipp_action_ref " \
306 "returned with error %d\n", err));
307 return (err);
308 }
309 /* unref old action */
310 err = ipp_action_unref(aid, dscpmk_data->next_action, flags);
311 ASSERT(err == 0);
312 dscpmk_data->next_action = next_action;
313 }
314
315 /*
316 * parse dscp_map, if present. Note that the module gets
317 * the entire array with unchanged entries marked with -1.
318 * If this array is absent during modification, it means revert to
319 * the default table.
320 */
321 if ((err = nvlist_lookup_int32_array(nvlp, DSCPMK_DSCP_MAP,
322 &tbl, &nelem)) == 0) {
323 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
324 if ((tbl[cnt] != DSCPMK_UNCHANGED_DSCP) && (tbl[cnt] !=
325 dscpmk_data->dscp_map[cnt])) {
326 dscpmk_data->dscp_map[cnt] = tbl[cnt];
327 }
328 }
329 } else {
330 bcopy(default_dscp_map, dscpmk_data->dscp_map,
331 sizeof (default_dscp_map));
332 }
333
334 /* parse summary_stats boolean, if present */
335 if ((err = nvlist_lookup_uint32(nvlp, IPP_ACTION_STATS_ENABLE, &bstats))
336 == 0) {
337 boolean_t val = (bstats != 0) ? B_TRUE : B_FALSE;
338 /* Turning on stats */
339 if (!dscpmk_data->summary_stats && val) {
340 if ((err = dscpmk_summ_statinit(aid, dscpmk_data))
341 != 0) {
342 nvlist_free(nvlp);
343 return (err);
344 }
345 /* Turning off stats */
346 } else if (!val && dscpmk_data->summary_stats) {
347 ipp_stat_destroy(dscpmk_data->stats);
348
349 }
350 dscpmk_data->summary_stats = val;
351 }
352
353 /* parse detailed_stats boolean */
354 if ((err = nvlist_lookup_uint32(nvlp, DSCPMK_DETAILED_STATS, &bstats))
355 == 0) {
356 boolean_t val = (bstats != 0) ? B_TRUE : B_FALSE;
357 if (dscpmk_data->detailed_stats && !val) {
358 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
359 if (dscpmk_data->dscp_stats[cnt].present) {
360 dscpmk_data->dscp_stats[cnt].present =
361 B_FALSE;
362 ipp_stat_destroy(dscpmk_data->
363 dscp_stats[cnt].stats);
364 }
365 }
366 }
367 dscpmk_data->detailed_stats = val;
368 }
369
370 /* The map might have changed */
371 if (dscpmk_data->detailed_stats) {
372 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
373 int val = dscpmk_data->dscp_map[cnt];
374 if (!dscpmk_data->dscp_stats[val].present) {
375 dscpmk_data->dscp_stats[val].present = B_TRUE;
376 if ((err = dscpmk_det_statinit(aid, dscpmk_data,
377 val)) != 0) {
378 nvlist_free(nvlp);
379 return (err);
380 }
381 }
382 }
383 }
384
385 /* Free the nvlist */
386 nvlist_free(nvlp);
387 return (0);
388 }
389
390 static int
391 dscpmk_destroy_action(ipp_action_id_t aid, ipp_flags_t flags)
392 {
393 dscpmk_data_t *dscpmk_data;
394 int err, cnt;
395
396 dscpmk_data = (dscpmk_data_t *)ipp_action_get_ptr(aid);
397 ASSERT(dscpmk_data != NULL);
398
399 /* Destroy stats, if gathered */
400 if (dscpmk_data->summary_stats) {
401 ipp_stat_destroy(dscpmk_data->stats);
402 }
403
404 if (dscpmk_data->detailed_stats) {
405 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
406 if (dscpmk_data->dscp_stats[cnt].present) {
407 ipp_stat_destroy(dscpmk_data->dscp_stats[cnt].
408 stats);
409 }
410 }
411 }
412
413 /* unreference the action */
414 err = ipp_action_unref(aid, dscpmk_data->next_action, flags);
415 ASSERT(err == 0);
416
417 kmem_free(dscpmk_data, DSCPMK_DATA_SZ);
418 return (0);
419 }
420
421 static int
422 dscpmk_invoke_action(ipp_action_id_t aid, ipp_packet_t *packet)
423 {
424 dscpmk_data_t *dscpmk_data;
425 mblk_t *mp = NULL;
426 ip_priv_t *priv;
427 int err;
428
429 ASSERT(packet != NULL);
430
431 /* get mblk from ipp_packet structure */
432 mp = ipp_packet_get_data(packet);
433 priv = (ip_priv_t *)ipp_packet_get_private(packet);
434
435 dscpmk_data = (dscpmk_data_t *)ipp_action_get_ptr(aid);
436 ASSERT(dscpmk_data != NULL);
437
438 /* dscpmk packet as configured */
439 if ((err = dscpmk_process(&mp, dscpmk_data, priv->proc)) != 0) {
440 return (err);
441 } else {
442 /* return packet with next action set */
443 return (ipp_packet_next(packet, dscpmk_data->next_action));
444 }
445 }
446
447 static int
448 dscpmk_det_statinit(ipp_action_id_t aid, dscpmk_data_t *dscpmk_data, int val)
449 {
450 int err = 0;
451 dscpmk_dscp_stats_t *statp;
452 char stats_string[15];
453
454 (void) sprintf(stats_string, "dscpmk_dscp0x%x", val);
455
456 /* install stats entry */
457 if ((err = ipp_stat_create(aid, stats_string, DSCPMK_DSCP_STATS_COUNT,
458 dscpmk_update_det_stats, dscpmk_data,
459 &dscpmk_data->dscp_stats[val].stats)) != 0) {
460 dscpmk0dbg(("dscpmk_det_statinit: ipp_stat_create returned "\
461 "with error %d\n", err));
462 return (err);
463 }
464
465 statp = (dscpmk_dscp_stats_t *)
466 (dscpmk_data->dscp_stats[val].stats)->ipps_data;
467 ASSERT(statp != NULL);
468
469 if ((err = ipp_stat_named_init(dscpmk_data->dscp_stats[val].stats,
470 "dscp", IPP_STAT_UINT32, &statp->dscp)) != 0) {
471 dscpmk0dbg(("dscpmk_det_statinit: ipp_stat_named_init "\
472 "returned with error %d\n", err));
473 return (err);
474 }
475
476 if ((err = ipp_stat_named_init(dscpmk_data->dscp_stats[val].stats,
477 "npackets", IPP_STAT_UINT64, &statp->npackets)) != 0) {
478 dscpmk0dbg(("dscpmk_det_statinit: ipp_stat_named_init "\
479 "returned with error %d\n", err));
480 return (err);
481 }
482
483 ipp_stat_install(dscpmk_data->dscp_stats[val].stats);
484 return (0);
485 }
486
487
488 static int
489 dscpmk_summ_statinit(ipp_action_id_t aid, dscpmk_data_t *dscpmk_data)
490 {
491 int err = 0;
492 dscpmk_stat_t *statp;
493
494 /* install stats entry */
495 if ((err = ipp_stat_create(aid, DSCPMK_STATS_STRING, DSCPMK_STATS_COUNT,
496 dscpmk_update_stats, dscpmk_data, &dscpmk_data->stats)) != 0) {
497 dscpmk0dbg(("dscpmk_create_action: ipp_stat_create returned " \
498 "with error %d\n", err));
499 return (err);
500 }
501
502 statp = (dscpmk_stat_t *)(dscpmk_data->stats)->ipps_data;
503 ASSERT(statp != NULL);
504
505 if ((err = ipp_stat_named_init(dscpmk_data->stats, "npackets",
506 IPP_STAT_UINT64, &statp->npackets)) != 0) {
507 dscpmk0dbg(("dscpmk_summ_statinit: ipp_stat_named_init " \
508 "returned with error %d\n", err));
509 return (err);
510 }
511
512 if ((err = ipp_stat_named_init(dscpmk_data->stats, "dscp_changed",
513 IPP_STAT_UINT64, &statp->dscp_changed)) != 0) {
514 dscpmk0dbg(("dscpmk_summ_statinit: ipp_stat_named_init " \
515 "returned with error %d\n", err));
516 return (err);
517 }
518
519 if ((err = ipp_stat_named_init(dscpmk_data->stats, "dscp_unchanged",
520 IPP_STAT_UINT64, &statp->dscp_unchanged)) != 0) {
521 dscpmk0dbg(("dscpmk_summ_statinit: ipp_stat_named_init " \
522 "returned with error %d\n", err));
523 return (err);
524 }
525
526 if ((err = ipp_stat_named_init(dscpmk_data->stats, "ipackets",
527 IPP_STAT_UINT64, &statp->ipackets)) != 0) {
528 dscpmk0dbg(("dscpmk_summ_statinit: ipp_stat_named_init " \
529 "returned with error %d\n", err));
530 return (err);
531 }
532
533 if ((err = ipp_stat_named_init(dscpmk_data->stats, "epackets",
534 IPP_STAT_UINT64, &statp->epackets)) != 0) {
535 dscpmk0dbg(("dscpmk_summ_statinit: ipp_stat_named_init " \
536 "returned with error %d\n", err));
537 return (err);
538 }
539
540 ipp_stat_install(dscpmk_data->stats);
541 return (0);
542 }
543
544 /* ARGSUSED */
545 static int
546 dscpmk_update_det_stats(ipp_stat_t *sp, void *arg, int rw)
547 {
548 dscpmk_data_t *dscpmk_data = (dscpmk_data_t *)arg;
549 dscpmk_dscp_stats_t *statp;
550 uint32_t count;
551
552 for (count = 0; count < DSCPMK_ARRAY_COUNT; count++) {
553 if (!dscpmk_data->dscp_stats[count].present)
554 continue;
555 statp = (dscpmk_dscp_stats_t *)
556 (dscpmk_data->dscp_stats[count].stats)->ipps_data;
557 ASSERT(statp != NULL);
558 (void) ipp_stat_named_op(&statp->npackets,
559 &dscpmk_data->dscp_stats[count].npackets, rw);
560 (void) ipp_stat_named_op(&statp->dscp, &count, rw);
561 }
562 return (0);
563 }
564
565 static int
566 dscpmk_update_stats(ipp_stat_t *sp, void *arg, int rw)
567 {
568 dscpmk_data_t *dscpmk_data = (dscpmk_data_t *)arg;
569 dscpmk_stat_t *snames = (dscpmk_stat_t *)sp->ipps_data;
570 ASSERT(dscpmk_data != NULL);
571 ASSERT(snames != NULL);
572
573 (void) ipp_stat_named_op(&snames->npackets, &dscpmk_data->npackets, rw);
574 (void) ipp_stat_named_op(&snames->dscp_changed, &dscpmk_data->changed,
575 rw);
576 (void) ipp_stat_named_op(&snames->dscp_unchanged,
577 &dscpmk_data->unchanged, rw);
578 (void) ipp_stat_named_op(&snames->ipackets, &dscpmk_data->ipackets, rw);
579 (void) ipp_stat_named_op(&snames->epackets, &dscpmk_data->epackets, rw);
580
581 return (0);
582 }
583
584 /* ARGSUSED */
585 static int
586 dscpmk_info(ipp_action_id_t aid, int (*fn)(nvlist_t *, void *), void *arg,
587 ipp_flags_t flags)
588 {
589 nvlist_t *nvlp;
590 dscpmk_data_t *dscpmk_data;
591 char *next_action;
592 int err, cnt;
593 int32_t dscp_map[DSCPMK_ARRAY_COUNT];
594
595 ASSERT(fn != NULL);
596
597 dscpmk_data = (dscpmk_data_t *)ipp_action_get_ptr(aid);
598 ASSERT(dscpmk_data != NULL);
599
600 /* allocate nvlist to be passed back */
601 if ((err = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) {
602 dscpmk0dbg(("dscpmk_info: error allocating memory\n"));
603 return (err);
604 }
605
606 /* look up next action with the next action id */
607 if ((err = ipp_action_name(dscpmk_data->next_action,
608 &next_action)) != 0) {
609 dscpmk0dbg(("dscpmk_info: next action not available\n"));
610 nvlist_free(nvlp);
611 return (err);
612 }
613
614 /* add next action name */
615 if ((err = nvlist_add_string(nvlp, DSCPMK_NEXT_ACTION_NAME,
616 next_action)) != 0) {
617 dscpmk0dbg(("dscpmk_info: error adding next action\n"));
618 nvlist_free(nvlp);
619 kmem_free(next_action, (strlen(next_action) + 1));
620 return (err);
621 }
622
623 /* free action name */
624 kmem_free(next_action, (strlen(next_action) + 1));
625
626 /* add config type */
627 if ((err = nvlist_add_byte(nvlp, IPP_CONFIG_TYPE, IPP_SET)) != 0) {
628 dscpmk0dbg(("dscpmk_info: error adding config type\n"));
629 nvlist_free(nvlp);
630 return (err);
631 }
632
633 /* add dscp map */
634 bcopy(dscpmk_data->dscp_map, dscp_map, sizeof (dscp_map));
635 for (cnt = 0; cnt < DSCPMK_ARRAY_COUNT; cnt++) {
636 dscp_map[cnt] = dscpmk_data->dscp_map[cnt];
637 }
638 if ((err = nvlist_add_int32_array(nvlp, DSCPMK_DSCP_MAP,
639 dscp_map, DSCPMK_ARRAY_COUNT)) != 0) {
640 dscpmk0dbg(("dscpmk_info: error adding dscp map\n"));
641 nvlist_free(nvlp);
642 return (err);
643 }
644
645 /* add summary stats boolean */
646 if ((err = nvlist_add_uint32(nvlp, IPP_ACTION_STATS_ENABLE,
647 (dscpmk_data->summary_stats ? 1 : 0))) != 0) {
648 dscpmk0dbg(("dscpmk_info: error adding stats status\n"));
649 nvlist_free(nvlp);
650 return (err);
651 }
652
653 /* add detailed stats boolean */
654 if ((err = nvlist_add_uint32(nvlp, DSCPMK_DETAILED_STATS,
655 (dscpmk_data->detailed_stats ? 1 : 0))) != 0) {
656 dscpmk0dbg(("dscpmk_info: error adding det stats status\n"));
657 nvlist_free(nvlp);
658 return (err);
659 }
660
661 /* call back with nvlist */
662 err = fn(nvlp, arg);
663
664 nvlist_free(nvlp);
665 return (err);
666 }