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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <door.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <zone.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/aggr.h>
37 #include <sys/mman.h>
38 #include <fcntl.h>
39 #include <libdladm.h>
40 #include <libdladm_impl.h>
41 #include <libdllink.h>
42 #include <libdlmgmt.h>
43
44 /*
45 * Table of data type sizes indexed by dladm_datatype_t.
46 */
47 static size_t dladm_datatype_size[] = {
48 0, /* DLADM_TYPE_STR, use strnlen() */
49 sizeof (boolean_t), /* DLADM_TYPE_BOOLEAN */
50 sizeof (uint64_t) /* DLADM_TYPE_UINT64 */
51 };
52
53 static dladm_status_t
54 dladm_door_call(dladm_handle_t handle, void *arg, size_t asize, void *rbuf,
55 size_t *rsizep)
56 {
57 door_arg_t darg;
58 int door_fd;
59 dladm_status_t status;
60 boolean_t reopen = B_FALSE;
61
62 darg.data_ptr = arg;
63 darg.data_size = asize;
64 darg.desc_ptr = NULL;
65 darg.desc_num = 0;
66 darg.rbuf = rbuf;
67 darg.rsize = *rsizep;
68
69 reopen:
70 /* The door descriptor is opened if it isn't already */
71 if ((status = dladm_door_fd(handle, &door_fd)) != DLADM_STATUS_OK)
72 return (status);
73 if (door_call(door_fd, &darg) == -1) {
74 /*
75 * Stale door descriptor is possible if dlmgmtd was re-started
76 * since last door_fd open so try re-opening door file.
77 */
78 if (!reopen && errno == EBADF) {
79 (void) close(handle->door_fd);
80 handle->door_fd = -1;
81 reopen = B_TRUE;
82 goto reopen;
83 }
84 status = dladm_errno2status(errno);
85 }
86 if (status != DLADM_STATUS_OK)
87 return (status);
88
89 if (darg.rbuf != rbuf) {
90 /*
91 * The size of the input rbuf is not big enough so that
92 * the door allocate the rbuf itself. In this case, return
93 * the required size to the caller.
94 */
95 (void) munmap(darg.rbuf, darg.rsize);
96 *rsizep = darg.rsize;
97 return (DLADM_STATUS_TOOSMALL);
98 } else if (darg.rsize != *rsizep) {
99 return (DLADM_STATUS_FAILED);
100 }
101
102 return (dladm_errno2status(((dlmgmt_retval_t *)rbuf)->lr_err));
103 }
104
105 /*
106 * Allocate a new linkid with the given name. Return the new linkid.
107 */
108 dladm_status_t
109 dladm_create_datalink_id(dladm_handle_t handle, const char *link,
110 datalink_class_t class, uint32_t media, uint32_t flags,
111 datalink_id_t *linkidp)
112 {
113 dlmgmt_door_createid_t createid;
114 dlmgmt_createid_retval_t retval;
115 uint32_t dlmgmt_flags;
116 dladm_status_t status;
117 size_t sz = sizeof (retval);
118
119 if (link == NULL || class == DATALINK_CLASS_ALL ||
120 !(flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST)) ||
121 linkidp == NULL) {
122 return (DLADM_STATUS_BADARG);
123 }
124
125 dlmgmt_flags = (flags & DLADM_OPT_ACTIVE) ? DLMGMT_ACTIVE : 0;
126 dlmgmt_flags |= (flags & DLADM_OPT_PERSIST) ? DLMGMT_PERSIST : 0;
127
128 (void) strlcpy(createid.ld_link, link, MAXLINKNAMELEN);
129 createid.ld_class = class;
130 createid.ld_media = media;
131 createid.ld_flags = dlmgmt_flags;
132 createid.ld_cmd = DLMGMT_CMD_CREATE_LINKID;
133 createid.ld_prefix = (flags & DLADM_OPT_PREFIX);
134
135 if ((status = dladm_door_call(handle, &createid, sizeof (createid),
136 &retval, &sz)) == DLADM_STATUS_OK) {
137 *linkidp = retval.lr_linkid;
138 }
139 return (status);
140 }
141
142 /*
143 * Destroy the given link ID.
144 */
145 dladm_status_t
146 dladm_destroy_datalink_id(dladm_handle_t handle, datalink_id_t linkid,
147 uint32_t flags)
148 {
149 dlmgmt_door_destroyid_t destroyid;
150 dlmgmt_destroyid_retval_t retval;
151 uint32_t dlmgmt_flags;
152 size_t sz = sizeof (retval);
153
154 dlmgmt_flags = (flags & DLADM_OPT_ACTIVE) ? DLMGMT_ACTIVE : 0;
155 dlmgmt_flags |= ((flags & DLADM_OPT_PERSIST) ? DLMGMT_PERSIST : 0);
156
157 destroyid.ld_cmd = DLMGMT_CMD_DESTROY_LINKID;
158 destroyid.ld_linkid = linkid;
159 destroyid.ld_flags = dlmgmt_flags;
160
161 return (dladm_door_call(handle, &destroyid, sizeof (destroyid),
162 &retval, &sz));
163 }
164
165 /*
166 * Remap a given link ID to a new name.
167 */
168 dladm_status_t
169 dladm_remap_datalink_id(dladm_handle_t handle, datalink_id_t linkid,
170 const char *link)
171 {
172 dlmgmt_door_remapid_t remapid;
173 dlmgmt_remapid_retval_t retval;
174 size_t sz = sizeof (retval);
175
176 remapid.ld_cmd = DLMGMT_CMD_REMAP_LINKID;
177 remapid.ld_linkid = linkid;
178 (void) strlcpy(remapid.ld_link, link, MAXLINKNAMELEN);
179
180 return (dladm_door_call(handle, &remapid, sizeof (remapid),
181 &retval, &sz));
182 }
183
184 /*
185 * Make a given link ID active.
186 */
187 dladm_status_t
188 dladm_up_datalink_id(dladm_handle_t handle, datalink_id_t linkid)
189 {
190 dlmgmt_door_upid_t upid;
191 dlmgmt_upid_retval_t retval;
192 size_t sz = sizeof (retval);
193
194 upid.ld_cmd = DLMGMT_CMD_UP_LINKID;
195 upid.ld_linkid = linkid;
196
197 return (dladm_door_call(handle, &upid, sizeof (upid), &retval, &sz));
198 }
199
200 /*
201 * Create a new link with the given name. Return the new link's handle
202 */
203 dladm_status_t
204 dladm_create_conf(dladm_handle_t handle, const char *link, datalink_id_t linkid,
205 datalink_class_t class, uint32_t media, dladm_conf_t *confp)
206 {
207 dlmgmt_door_createconf_t createconf;
208 dlmgmt_createconf_retval_t retval;
209 dladm_status_t status;
210 size_t sz = sizeof (retval);
211
212 if (link == NULL || confp == NULL)
213 return (DLADM_STATUS_BADARG);
214
215 (void) strlcpy(createconf.ld_link, link, MAXLINKNAMELEN);
216 createconf.ld_class = class;
217 createconf.ld_media = media;
218 createconf.ld_linkid = linkid;
219 createconf.ld_cmd = DLMGMT_CMD_CREATECONF;
220 confp->ds_confid = DLADM_INVALID_CONF;
221
222 if ((status = dladm_door_call(handle, &createconf, sizeof (createconf),
223 &retval, &sz)) == DLADM_STATUS_OK) {
224 confp->ds_readonly = B_FALSE;
225 confp->ds_confid = retval.lr_confid;
226 }
227 return (status);
228 }
229
230 /*
231 * An active physical link reported by the dlmgmtd daemon might not be active
232 * anymore as this link might be removed during system shutdown. Check its
233 * real status by calling dladm_phys_info().
234 */
235 dladm_status_t
236 i_dladm_phys_status(dladm_handle_t handle, datalink_id_t linkid,
237 uint32_t *flagsp)
238 {
239 dladm_phys_attr_t dpa;
240 dladm_status_t status;
241
242 assert((*flagsp) & DLMGMT_ACTIVE);
243
244 status = dladm_phys_info(handle, linkid, &dpa, DLADM_OPT_ACTIVE);
245 if (status == DLADM_STATUS_NOTFOUND) {
246 /*
247 * No active status, this link was removed. Update its status
248 * in the daemon and delete all active linkprops.
249 *
250 * Note that the operation could fail. If it does, return
251 * failure now since otherwise dladm_set_linkprop() might
252 * call back to i_dladm_phys_status() recursively.
253 */
254 if ((status = dladm_destroy_datalink_id(handle, linkid,
255 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK)
256 return (status);
257
258 (void) dladm_set_linkprop(handle, linkid, NULL, NULL, 0,
259 DLADM_OPT_ACTIVE);
260
261 (*flagsp) &= ~DLMGMT_ACTIVE;
262 status = DLADM_STATUS_OK;
263 }
264 return (status);
265 }
266
267 /*
268 * Walk each entry in the data link configuration repository and
269 * call fn on the linkid and arg.
270 */
271 dladm_status_t
272 dladm_walk_datalink_id(int (*fn)(dladm_handle_t, datalink_id_t, void *),
273 dladm_handle_t handle, void *argp, datalink_class_t class,
274 datalink_media_t dmedia, uint32_t flags)
275 {
276 dlmgmt_door_getnext_t getnext;
277 dlmgmt_getnext_retval_t retval;
278 uint32_t dlmgmt_flags;
279 datalink_id_t linkid = DATALINK_INVALID_LINKID;
280 dladm_status_t status = DLADM_STATUS_OK;
281 size_t sz = sizeof (retval);
282
283 if (fn == NULL)
284 return (DLADM_STATUS_BADARG);
285
286 dlmgmt_flags = (flags & DLADM_OPT_ACTIVE) ? DLMGMT_ACTIVE : 0;
287 dlmgmt_flags |= ((flags & DLADM_OPT_PERSIST) ? DLMGMT_PERSIST : 0);
288
289 getnext.ld_cmd = DLMGMT_CMD_GETNEXT;
290 getnext.ld_class = class;
291 getnext.ld_dmedia = dmedia;
292 getnext.ld_flags = dlmgmt_flags;
293
294 do {
295 getnext.ld_linkid = linkid;
296 if ((status = dladm_door_call(handle, &getnext,
297 sizeof (getnext), &retval, &sz)) != DLADM_STATUS_OK) {
298 /*
299 * Done with walking. If no next datalink is found,
300 * return success.
301 */
302 if (status == DLADM_STATUS_NOTFOUND)
303 status = DLADM_STATUS_OK;
304 break;
305 }
306
307 linkid = retval.lr_linkid;
308 if ((retval.lr_class == DATALINK_CLASS_PHYS) &&
309 (retval.lr_flags & DLMGMT_ACTIVE)) {
310 /*
311 * An active physical link reported by the dlmgmtd
312 * daemon might not be active anymore. Check its
313 * real status.
314 */
315 if (i_dladm_phys_status(handle, linkid,
316 &retval.lr_flags) != DLADM_STATUS_OK) {
317 continue;
318 }
319
320 if (!(dlmgmt_flags & retval.lr_flags))
321 continue;
322 }
323
324 if (fn(handle, linkid, argp) == DLADM_WALK_TERMINATE)
325 break;
326 } while (linkid != DATALINK_INVALID_LINKID);
327
328 return (status);
329 }
330
331 /*
332 * Get a handle of a copy of the link configuration (kept in the daemon)
333 * for the given link so it can be updated later by dladm_write_conf().
334 */
335 dladm_status_t
336 dladm_open_conf(dladm_handle_t handle, datalink_id_t linkid,
337 dladm_conf_t *confp)
338 {
339 dlmgmt_door_openconf_t openconf;
340 dlmgmt_openconf_retval_t retval;
341 dladm_status_t status;
342 size_t sz;
343
344 if (linkid == DATALINK_INVALID_LINKID || confp == NULL)
345 return (DLADM_STATUS_BADARG);
346
347 sz = sizeof (retval);
348 openconf.ld_linkid = linkid;
349 openconf.ld_cmd = DLMGMT_CMD_OPENCONF;
350 confp->ds_confid = DLADM_INVALID_CONF;
351 if ((status = dladm_door_call(handle, &openconf,
352 sizeof (openconf), &retval, &sz)) == DLADM_STATUS_OK) {
353 confp->ds_readonly = B_FALSE;
354 confp->ds_confid = retval.lr_confid;
355 }
356
357 return (status);
358 }
359
360 /*
361 * Get the handle of a local snapshot of the link configuration. Note that
362 * any operations with this handle are read-only, i.e., one can not update
363 * the configuration with this handle.
364 */
365 dladm_status_t
366 dladm_getsnap_conf(dladm_handle_t handle, datalink_id_t linkid,
367 dladm_conf_t *confp)
368 {
369 dlmgmt_door_getconfsnapshot_t snapshot;
370 dlmgmt_getconfsnapshot_retval_t *retvalp;
371 char *nvlbuf;
372 dladm_status_t status;
373 int err;
374 size_t sz;
375
376 if (linkid == DATALINK_INVALID_LINKID || confp == NULL)
377 return (DLADM_STATUS_BADARG);
378
379 sz = sizeof (dlmgmt_getconfsnapshot_retval_t);
380 snapshot.ld_linkid = linkid;
381 snapshot.ld_cmd = DLMGMT_CMD_GETCONFSNAPSHOT;
382 again:
383 if ((retvalp = malloc(sz)) == NULL)
384 return (DLADM_STATUS_NOMEM);
385
386 if ((status = dladm_door_call(handle, &snapshot, sizeof (snapshot),
387 retvalp, &sz)) == DLADM_STATUS_TOOSMALL) {
388 free(retvalp);
389 goto again;
390 }
391
392 if (status != DLADM_STATUS_OK) {
393 free(retvalp);
394 return (status);
395 }
396
397 confp->ds_readonly = B_TRUE;
398 nvlbuf = (char *)retvalp + sizeof (dlmgmt_getconfsnapshot_retval_t);
399 if ((err = nvlist_unpack(nvlbuf, retvalp->lr_nvlsz,
400 &(confp->ds_nvl), NV_ENCODE_NATIVE)) != 0) {
401 status = dladm_errno2status(err);
402 }
403 free(retvalp);
404 return (status);
405 }
406
407 /*
408 * Commit the given link to the data link configuration repository so
409 * that it will persist across reboots.
410 */
411 dladm_status_t
412 dladm_write_conf(dladm_handle_t handle, dladm_conf_t conf)
413 {
414 dlmgmt_door_writeconf_t writeconf;
415 dlmgmt_writeconf_retval_t retval;
416 size_t sz = sizeof (retval);
417
418 if (conf.ds_confid == DLADM_INVALID_CONF)
419 return (DLADM_STATUS_BADARG);
420
421 if (conf.ds_readonly)
422 return (DLADM_STATUS_DENIED);
423
424 writeconf.ld_cmd = DLMGMT_CMD_WRITECONF;
425 writeconf.ld_confid = conf.ds_confid;
426
427 return (dladm_door_call(handle, &writeconf, sizeof (writeconf),
428 &retval, &sz));
429 }
430
431 /*
432 * Given a dladm_conf_t, get the specific configuration field
433 *
434 * If the specified dladm_conf_t is a read-only snapshot of the configuration,
435 * get a specific link propertie from that snapshot (nvl), otherwise, get
436 * the link protperty from the dlmgmtd daemon using the given confid.
437 */
438 dladm_status_t
439 dladm_get_conf_field(dladm_handle_t handle, dladm_conf_t conf, const char *attr,
440 void *attrval, size_t attrsz)
441 {
442 dladm_status_t status = DLADM_STATUS_OK;
443
444 if (attrval == NULL || attrsz == 0 || attr == NULL)
445 return (DLADM_STATUS_BADARG);
446
447 if (conf.ds_readonly) {
448 uchar_t *oattrval;
449 uint32_t oattrsz;
450 int err;
451
452 if ((err = nvlist_lookup_byte_array(conf.ds_nvl, (char *)attr,
453 &oattrval, &oattrsz)) != 0) {
454 return (dladm_errno2status(err));
455 }
456 if (oattrsz > attrsz)
457 return (DLADM_STATUS_TOOSMALL);
458
459 bcopy(oattrval, attrval, oattrsz);
460 } else {
461 dlmgmt_door_getattr_t getattr;
462 dlmgmt_getattr_retval_t retval;
463 size_t sz = sizeof (retval);
464
465 if (conf.ds_confid == DLADM_INVALID_CONF)
466 return (DLADM_STATUS_BADARG);
467
468 getattr.ld_cmd = DLMGMT_CMD_GETATTR;
469 getattr.ld_confid = conf.ds_confid;
470 (void) strlcpy(getattr.ld_attr, attr, MAXLINKATTRLEN);
471
472 if ((status = dladm_door_call(handle, &getattr,
473 sizeof (getattr), &retval, &sz)) != DLADM_STATUS_OK) {
474 return (status);
475 }
476
477 if (retval.lr_attrsz > attrsz)
478 return (DLADM_STATUS_TOOSMALL);
479
480 bcopy(retval.lr_attrval, attrval, retval.lr_attrsz);
481 }
482 return (status);
483 }
484
485 /*
486 * Get next property attribute from data link configuration repository.
487 * If last_attr is "", return the first property.
488 */
489 /* ARGSUSED */
490 dladm_status_t
491 dladm_getnext_conf_linkprop(dladm_handle_t handle, dladm_conf_t conf,
492 const char *last_attr, char *attr, void *attrval, size_t attrsz,
493 size_t *attrszp)
494 {
495 nvlist_t *nvl = conf.ds_nvl;
496 nvpair_t *last = NULL, *nvp;
497 uchar_t *oattrval;
498 uint32_t oattrsz;
499 int err;
500
501 if (nvl == NULL || attrval == NULL || attrsz == 0 || attr == NULL ||
502 !conf.ds_readonly)
503 return (DLADM_STATUS_BADARG);
504
505 while ((nvp = nvlist_next_nvpair(nvl, last)) != NULL) {
506 if (last_attr[0] == '\0')
507 break;
508 if (last != NULL && strcmp(last_attr, nvpair_name(last)) == 0)
509 break;
510 last = nvp;
511 }
512
513 if (nvp == NULL)
514 return (DLADM_STATUS_NOTFOUND);
515
516 if ((err = nvpair_value_byte_array(nvp, (uchar_t **)&oattrval,
517 &oattrsz)) != NULL) {
518 return (dladm_errno2status(err));
519 }
520
521 *attrszp = oattrsz;
522 if (oattrsz > attrsz)
523 return (DLADM_STATUS_TOOSMALL);
524
525 (void) strlcpy(attr, nvpair_name(nvp), MAXLINKATTRLEN);
526 bcopy(oattrval, attrval, oattrsz);
527 return (DLADM_STATUS_OK);
528 }
529
530 /*
531 * Get the link ID that is associated with the given name.
532 */
533 dladm_status_t
534 dladm_name2info(dladm_handle_t handle, const char *link, datalink_id_t *linkidp,
535 uint32_t *flagp, datalink_class_t *classp, uint32_t *mediap)
536 {
537 dlmgmt_door_getlinkid_t getlinkid;
538 dlmgmt_getlinkid_retval_t retval;
539 datalink_id_t linkid;
540 dladm_status_t status;
541 size_t sz = sizeof (retval);
542
543 getlinkid.ld_cmd = DLMGMT_CMD_GETLINKID;
544 (void) strlcpy(getlinkid.ld_link, link, MAXLINKNAMELEN);
545
546 if ((status = dladm_door_call(handle, &getlinkid, sizeof (getlinkid),
547 &retval, &sz)) != DLADM_STATUS_OK) {
548 return (status);
549 }
550
551 linkid = retval.lr_linkid;
552 if (retval.lr_class == DATALINK_CLASS_PHYS &&
553 retval.lr_flags & DLMGMT_ACTIVE) {
554 /*
555 * An active physical link reported by the dlmgmtd daemon
556 * might not be active anymore. Check and set its real status.
557 */
558 status = i_dladm_phys_status(handle, linkid, &retval.lr_flags);
559 if (status != DLADM_STATUS_OK)
560 return (status);
561 }
562
563 if (linkidp != NULL)
564 *linkidp = linkid;
565 if (flagp != NULL) {
566 *flagp = retval.lr_flags & DLMGMT_ACTIVE ? DLADM_OPT_ACTIVE : 0;
567 *flagp |= (retval.lr_flags & DLMGMT_PERSIST) ?
568 DLADM_OPT_PERSIST : 0;
569 }
570 if (classp != NULL)
571 *classp = retval.lr_class;
572 if (mediap != NULL)
573 *mediap = retval.lr_media;
574
575 return (DLADM_STATUS_OK);
576 }
577
578 /*
579 * Get the link name that is associated with the given id.
580 */
581 dladm_status_t
582 dladm_datalink_id2info(dladm_handle_t handle, datalink_id_t linkid,
583 uint32_t *flagp, datalink_class_t *classp, uint32_t *mediap, char *link,
584 size_t len)
585 {
586 dlmgmt_door_getname_t getname;
587 dlmgmt_getname_retval_t retval;
588 dladm_status_t status;
589 size_t sz = sizeof (retval);
590
591 if ((linkid == DATALINK_INVALID_LINKID) || (link != NULL && len == 0) ||
592 (link == NULL && len != 0)) {
593 return (DLADM_STATUS_BADARG);
594 }
595
596 getname.ld_cmd = DLMGMT_CMD_GETNAME;
597 getname.ld_linkid = linkid;
598 if ((status = dladm_door_call(handle, &getname, sizeof (getname),
599 &retval, &sz)) != DLADM_STATUS_OK) {
600 return (status);
601 }
602
603 if (len != 0 && (strlen(retval.lr_link) + 1 > len))
604 return (DLADM_STATUS_TOOSMALL);
605
606 if (retval.lr_class == DATALINK_CLASS_PHYS &&
607 retval.lr_flags & DLMGMT_ACTIVE) {
608 /*
609 * An active physical link reported by the dlmgmtd daemon
610 * might not be active anymore. Check and set its real status.
611 */
612 status = i_dladm_phys_status(handle, linkid, &retval.lr_flags);
613 if (status != DLADM_STATUS_OK)
614 return (status);
615 }
616
617 if (link != NULL)
618 (void) strlcpy(link, retval.lr_link, len);
619 if (classp != NULL)
620 *classp = retval.lr_class;
621 if (mediap != NULL)
622 *mediap = retval.lr_media;
623 if (flagp != NULL) {
624 *flagp = retval.lr_flags & DLMGMT_ACTIVE ?
625 DLADM_OPT_ACTIVE : 0;
626 *flagp |= (retval.lr_flags & DLMGMT_PERSIST) ?
627 DLADM_OPT_PERSIST : 0;
628 }
629 return (DLADM_STATUS_OK);
630 }
631
632 /*
633 * Set the given attr with the given attrval for the given link.
634 */
635 dladm_status_t
636 dladm_set_conf_field(dladm_handle_t handle, dladm_conf_t conf, const char *attr,
637 dladm_datatype_t type, const void *attrval)
638 {
639 dlmgmt_door_setattr_t setattr;
640 dlmgmt_setattr_retval_t retval;
641 size_t attrsz;
642 size_t sz = sizeof (retval);
643
644 if (attr == NULL || attrval == NULL)
645 return (DLADM_STATUS_BADARG);
646
647 if (conf.ds_readonly)
648 return (DLADM_STATUS_DENIED);
649
650 if (type == DLADM_TYPE_STR)
651 attrsz = strlen(attrval) + 1;
652 else
653 attrsz = dladm_datatype_size[type];
654
655 if (attrsz > MAXLINKATTRVALLEN)
656 return (DLADM_STATUS_TOOSMALL);
657
658 setattr.ld_cmd = DLMGMT_CMD_SETATTR;
659 setattr.ld_confid = conf.ds_confid;
660 (void) strlcpy(setattr.ld_attr, attr, MAXLINKATTRLEN);
661 setattr.ld_attrsz = attrsz;
662 setattr.ld_type = type;
663 bcopy(attrval, &setattr.ld_attrval, attrsz);
664
665 return (dladm_door_call(handle, &setattr, sizeof (setattr),
666 &retval, &sz));
667 }
668
669 /*
670 * Unset the given attr the given link.
671 */
672 dladm_status_t
673 dladm_unset_conf_field(dladm_handle_t handle, dladm_conf_t conf,
674 const char *attr)
675 {
676 dlmgmt_door_unsetattr_t unsetattr;
677 dlmgmt_unsetattr_retval_t retval;
678 size_t sz = sizeof (retval);
679
680 if (attr == NULL)
681 return (DLADM_STATUS_BADARG);
682
683 if (conf.ds_readonly)
684 return (DLADM_STATUS_DENIED);
685
686 unsetattr.ld_cmd = DLMGMT_CMD_UNSETATTR;
687 unsetattr.ld_confid = conf.ds_confid;
688 (void) strlcpy(unsetattr.ld_attr, attr, MAXLINKATTRLEN);
689
690 return (dladm_door_call(handle, &unsetattr, sizeof (unsetattr),
691 &retval, &sz));
692 }
693
694 /*
695 * Remove the given link ID and its entry from the data link configuration
696 * repository.
697 */
698 dladm_status_t
699 dladm_remove_conf(dladm_handle_t handle, datalink_id_t linkid)
700 {
701 dlmgmt_door_removeconf_t removeconf;
702 dlmgmt_removeconf_retval_t retval;
703 size_t sz = sizeof (retval);
704
705 removeconf.ld_cmd = DLMGMT_CMD_REMOVECONF;
706 removeconf.ld_linkid = linkid;
707
708 return (dladm_door_call(handle, &removeconf, sizeof (removeconf),
709 &retval, &sz));
710 }
711
712 /*
713 * Free the contents of the link structure.
714 */
715 void
716 dladm_destroy_conf(dladm_handle_t handle, dladm_conf_t conf)
717 {
718 dlmgmt_door_destroyconf_t dconf;
719 dlmgmt_destroyconf_retval_t retval;
720 size_t sz = sizeof (retval);
721
722 if (conf.ds_readonly) {
723 nvlist_free(conf.ds_nvl);
724 } else {
725 if (conf.ds_confid == DLADM_INVALID_CONF)
726 return;
727
728 dconf.ld_cmd = DLMGMT_CMD_DESTROYCONF;
729 dconf.ld_confid = conf.ds_confid;
730
731 (void) dladm_door_call(handle, &dconf, sizeof (dconf),
732 &retval, &sz);
733 }
734 }
735
736 dladm_status_t
737 dladm_zone_boot(dladm_handle_t handle, zoneid_t zoneid)
738 {
739 dlmgmt_door_zoneboot_t zoneboot;
740 dlmgmt_zoneboot_retval_t retval;
741 size_t sz = sizeof (retval);
742
743 zoneboot.ld_cmd = DLMGMT_CMD_ZONEBOOT;
744 zoneboot.ld_zoneid = zoneid;
745 return (dladm_door_call(handle, &zoneboot, sizeof (zoneboot),
746 &retval, &sz));
747 }
748
749 dladm_status_t
750 dladm_zone_halt(dladm_handle_t handle, zoneid_t zoneid)
751 {
752 dlmgmt_door_zonehalt_t zonehalt;
753 dlmgmt_zonehalt_retval_t retval;
754 size_t sz = sizeof (retval);
755
756 zonehalt.ld_cmd = DLMGMT_CMD_ZONEHALT;
757 zonehalt.ld_zoneid = zoneid;
758 return (dladm_door_call(handle, &zonehalt, sizeof (zonehalt),
759 &retval, &sz));
760 }