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 <stdio.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <string.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <stropts.h>
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <strings.h>
35 #include <libintl.h>
36 #include <net/if_types.h>
37 #include <net/if_dl.h>
38 #include <sys/dld.h>
39 #include <libdladm_impl.h>
40 #include <libvrrpadm.h>
41 #include <libdllink.h>
42 #include <libdlbridge.h>
43 #include <libdlvnic.h>
44
45 /*
46 * VNIC administration library.
47 */
48
49 /*
50 * Default random MAC address prefix (locally administered).
51 */
52 static char dladm_vnic_def_prefix[] = {0x02, 0x08, 0x20};
53
54 static dladm_status_t dladm_vnic_persist_conf(dladm_handle_t,
55 const char *name, dladm_vnic_attr_t *,
56 datalink_class_t);
57 static const char *dladm_vnic_macaddr2str(const uchar_t *, char *);
58 static dladm_status_t dladm_vnic_str2macaddr(const char *, uchar_t *);
59
60 /*
61 * Convert a diagnostic returned by the kernel into a dladm_status_t.
62 */
63 static dladm_status_t
dladm_vnic_diag2status(vnic_ioc_diag_t ioc_diag)64 dladm_vnic_diag2status(vnic_ioc_diag_t ioc_diag)
65 {
66 switch (ioc_diag) {
67 case VNIC_IOC_DIAG_NONE:
68 return (DLADM_STATUS_OK);
69 case VNIC_IOC_DIAG_MACADDRLEN_INVALID:
70 return (DLADM_STATUS_INVALIDMACADDRLEN);
71 case VNIC_IOC_DIAG_MACADDR_NIC:
72 return (DLADM_STATUS_INVALIDMACADDRNIC);
73 case VNIC_IOC_DIAG_MACADDR_INUSE:
74 return (DLADM_STATUS_INVALIDMACADDRINUSE);
75 case VNIC_IOC_DIAG_MACFACTORYSLOTINVALID:
76 return (DLADM_STATUS_MACFACTORYSLOTINVALID);
77 case VNIC_IOC_DIAG_MACFACTORYSLOTUSED:
78 return (DLADM_STATUS_MACFACTORYSLOTUSED);
79 case VNIC_IOC_DIAG_MACFACTORYSLOTALLUSED:
80 return (DLADM_STATUS_MACFACTORYSLOTALLUSED);
81 case VNIC_IOC_DIAG_MACFACTORYNOTSUP:
82 return (DLADM_STATUS_MACFACTORYNOTSUP);
83 case VNIC_IOC_DIAG_MACPREFIX_INVALID:
84 return (DLADM_STATUS_INVALIDMACPREFIX);
85 case VNIC_IOC_DIAG_MACPREFIXLEN_INVALID:
86 return (DLADM_STATUS_INVALIDMACPREFIXLEN);
87 case VNIC_IOC_DIAG_MACMARGIN_INVALID:
88 return (DLADM_STATUS_INVALID_MACMARGIN);
89 case VNIC_IOC_DIAG_NO_HWRINGS:
90 return (DLADM_STATUS_NO_HWRINGS);
91 case VNIC_IOC_DIAG_MACADDR_INVALID:
92 return (DLADM_STATUS_INVALIDMACADDR);
93 default:
94 return (DLADM_STATUS_FAILED);
95 }
96 }
97
98 /*
99 * Send a create command to the VNIC driver.
100 */
101 dladm_status_t
i_dladm_vnic_create_sys(dladm_handle_t handle,dladm_vnic_attr_t * attr)102 i_dladm_vnic_create_sys(dladm_handle_t handle, dladm_vnic_attr_t *attr)
103 {
104 int rc;
105 vnic_ioc_create_t ioc;
106 dladm_status_t status = DLADM_STATUS_OK;
107
108 bzero(&ioc, sizeof (ioc));
109 ioc.vc_vnic_id = attr->va_vnic_id;
110 ioc.vc_link_id = attr->va_link_id;
111 ioc.vc_mac_addr_type = attr->va_mac_addr_type;
112 ioc.vc_mac_len = attr->va_mac_len;
113 ioc.vc_mac_slot = attr->va_mac_slot;
114 ioc.vc_mac_prefix_len = attr->va_mac_prefix_len;
115 ioc.vc_vid = attr->va_vid;
116 ioc.vc_vrid = attr->va_vrid;
117 ioc.vc_af = attr->va_af;
118 ioc.vc_flags = attr->va_force ? VNIC_IOC_CREATE_FORCE : 0;
119
120 if (attr->va_mac_len > 0 || ioc.vc_mac_prefix_len > 0)
121 bcopy(attr->va_mac_addr, ioc.vc_mac_addr, MAXMACADDRLEN);
122 bcopy(&attr->va_resource_props, &ioc.vc_resource_props,
123 sizeof (mac_resource_props_t));
124 if (attr->va_link_id == DATALINK_INVALID_LINKID)
125 ioc.vc_flags |= VNIC_IOC_CREATE_ANCHOR;
126
127 rc = ioctl(dladm_dld_fd(handle), VNIC_IOC_CREATE, &ioc);
128 if (rc < 0)
129 status = dladm_errno2status(errno);
130
131 if (status != DLADM_STATUS_OK) {
132 if (ioc.vc_diag != VNIC_IOC_DIAG_NONE)
133 status = dladm_vnic_diag2status(ioc.vc_diag);
134 }
135 if (status != DLADM_STATUS_OK)
136 return (status);
137
138 attr->va_mac_addr_type = ioc.vc_mac_addr_type;
139 switch (ioc.vc_mac_addr_type) {
140 case VNIC_MAC_ADDR_TYPE_FACTORY:
141 attr->va_mac_slot = ioc.vc_mac_slot;
142 break;
143 case VNIC_MAC_ADDR_TYPE_RANDOM:
144 bcopy(ioc.vc_mac_addr, attr->va_mac_addr, MAXMACADDRLEN);
145 attr->va_mac_len = ioc.vc_mac_len;
146 break;
147 }
148 return (status);
149 }
150
151 /*
152 * Get the configuration information of the given VNIC.
153 */
154 static dladm_status_t
i_dladm_vnic_info_active(dladm_handle_t handle,datalink_id_t linkid,dladm_vnic_attr_t * attrp)155 i_dladm_vnic_info_active(dladm_handle_t handle, datalink_id_t linkid,
156 dladm_vnic_attr_t *attrp)
157 {
158 vnic_ioc_info_t ioc;
159 vnic_info_t *vnic;
160 int rc;
161 dladm_status_t status = DLADM_STATUS_OK;
162
163 bzero(&ioc, sizeof (ioc));
164 vnic = &ioc.vi_info;
165 vnic->vn_vnic_id = linkid;
166
167 rc = ioctl(dladm_dld_fd(handle), VNIC_IOC_INFO, &ioc);
168 if (rc != 0) {
169 status = dladm_errno2status(errno);
170 goto bail;
171 }
172
173 attrp->va_vnic_id = vnic->vn_vnic_id;
174 attrp->va_link_id = vnic->vn_link_id;
175 attrp->va_mac_addr_type = vnic->vn_mac_addr_type;
176 bcopy(vnic->vn_mac_addr, attrp->va_mac_addr, MAXMACADDRLEN);
177 attrp->va_mac_len = vnic->vn_mac_len;
178 attrp->va_mac_slot = vnic->vn_mac_slot;
179 attrp->va_mac_prefix_len = vnic->vn_mac_prefix_len;
180 attrp->va_vid = vnic->vn_vid;
181 attrp->va_vrid = vnic->vn_vrid;
182 attrp->va_af = vnic->vn_af;
183 attrp->va_force = vnic->vn_force;
184
185 bail:
186 return (status);
187 }
188
189 static dladm_status_t
i_dladm_vnic_info_persist(dladm_handle_t handle,datalink_id_t linkid,dladm_vnic_attr_t * attrp)190 i_dladm_vnic_info_persist(dladm_handle_t handle, datalink_id_t linkid,
191 dladm_vnic_attr_t *attrp)
192 {
193 dladm_conf_t conf;
194 dladm_status_t status;
195 char macstr[ETHERADDRL * 3];
196 char linkover[MAXLINKNAMELEN];
197 uint64_t u64;
198 datalink_class_t class;
199
200 attrp->va_vnic_id = linkid;
201 if ((status = dladm_getsnap_conf(handle, linkid, &conf)) !=
202 DLADM_STATUS_OK)
203 return (status);
204
205 status = dladm_get_conf_field(handle, conf, FLINKOVER, linkover,
206 sizeof (linkover));
207 if (status != DLADM_STATUS_OK) {
208 /*
209 * This isn't an error, etherstubs don't have a FLINKOVER
210 * property.
211 */
212 attrp->va_link_id = DATALINK_INVALID_LINKID;
213 } else {
214 if ((status = dladm_name2info(handle, linkover,
215 &attrp->va_link_id, NULL, NULL, NULL)) != DLADM_STATUS_OK)
216 goto done;
217 }
218
219 if ((status = dladm_datalink_id2info(handle, linkid, NULL, &class,
220 NULL, NULL, 0)) != DLADM_STATUS_OK)
221 goto done;
222
223 if (class == DATALINK_CLASS_VLAN) {
224 if (attrp->va_link_id == DATALINK_INVALID_LINKID) {
225 status = DLADM_STATUS_BADARG;
226 goto done;
227 }
228 attrp->va_mac_addr_type = VNIC_MAC_ADDR_TYPE_PRIMARY;
229 attrp->va_mac_len = 0;
230 } else {
231 status = dladm_get_conf_field(handle, conf, FMADDRTYPE, &u64,
232 sizeof (u64));
233 if (status != DLADM_STATUS_OK)
234 goto done;
235
236 attrp->va_mac_addr_type = (vnic_mac_addr_type_t)u64;
237
238 if ((status = dladm_get_conf_field(handle, conf, FVRID,
239 &u64, sizeof (u64))) != DLADM_STATUS_OK) {
240 attrp->va_vrid = VRRP_VRID_NONE;
241 } else {
242 attrp->va_vrid = (vrid_t)u64;
243 }
244
245 if ((status = dladm_get_conf_field(handle, conf, FVRAF,
246 &u64, sizeof (u64))) != DLADM_STATUS_OK) {
247 attrp->va_af = AF_UNSPEC;
248 } else {
249 attrp->va_af = (int)u64;
250 }
251
252 status = dladm_get_conf_field(handle, conf, FMADDRLEN, &u64,
253 sizeof (u64));
254 attrp->va_mac_len = ((status == DLADM_STATUS_OK) ?
255 (uint_t)u64 : ETHERADDRL);
256
257 status = dladm_get_conf_field(handle, conf, FMADDRSLOT, &u64,
258 sizeof (u64));
259 attrp->va_mac_slot = ((status == DLADM_STATUS_OK) ?
260 (int)u64 : -1);
261
262 status = dladm_get_conf_field(handle, conf, FMADDRPREFIXLEN,
263 &u64, sizeof (u64));
264 attrp->va_mac_prefix_len = ((status == DLADM_STATUS_OK) ?
265 (uint_t)u64 : sizeof (dladm_vnic_def_prefix));
266
267 status = dladm_get_conf_field(handle, conf, FMACADDR, macstr,
268 sizeof (macstr));
269 if (status != DLADM_STATUS_OK)
270 goto done;
271
272 status = dladm_vnic_str2macaddr(macstr, attrp->va_mac_addr);
273 if (status != DLADM_STATUS_OK)
274 goto done;
275 }
276
277 status = dladm_get_conf_field(handle, conf, FVLANID, &u64,
278 sizeof (u64));
279 attrp->va_vid = ((status == DLADM_STATUS_OK) ? (uint16_t)u64 : 0);
280
281 status = DLADM_STATUS_OK;
282 done:
283 dladm_destroy_conf(handle, conf);
284 return (status);
285 }
286
287 dladm_status_t
dladm_vnic_info(dladm_handle_t handle,datalink_id_t linkid,dladm_vnic_attr_t * attrp,uint32_t flags)288 dladm_vnic_info(dladm_handle_t handle, datalink_id_t linkid,
289 dladm_vnic_attr_t *attrp, uint32_t flags)
290 {
291 if (flags == DLADM_OPT_ACTIVE)
292 return (i_dladm_vnic_info_active(handle, linkid, attrp));
293 else if (flags == DLADM_OPT_PERSIST)
294 return (i_dladm_vnic_info_persist(handle, linkid, attrp));
295 else
296 return (DLADM_STATUS_BADARG);
297 }
298
299 /*
300 * Remove a VNIC from the kernel.
301 */
302 dladm_status_t
i_dladm_vnic_delete_sys(dladm_handle_t handle,datalink_id_t linkid)303 i_dladm_vnic_delete_sys(dladm_handle_t handle, datalink_id_t linkid)
304 {
305 vnic_ioc_delete_t ioc;
306 dladm_status_t status = DLADM_STATUS_OK;
307 int rc;
308
309 ioc.vd_vnic_id = linkid;
310
311 rc = ioctl(dladm_dld_fd(handle), VNIC_IOC_DELETE, &ioc);
312 if (rc < 0)
313 status = dladm_errno2status(errno);
314
315 return (status);
316 }
317
318 /*
319 * Convert between MAC address types and their string representations.
320 */
321
322 typedef struct dladm_vnic_addr_type_s {
323 const char *va_str;
324 vnic_mac_addr_type_t va_type;
325 } dladm_vnic_addr_type_t;
326
327 static dladm_vnic_addr_type_t addr_types[] = {
328 {"fixed", VNIC_MAC_ADDR_TYPE_FIXED},
329 {"random", VNIC_MAC_ADDR_TYPE_RANDOM},
330 {"factory", VNIC_MAC_ADDR_TYPE_FACTORY},
331 {"auto", VNIC_MAC_ADDR_TYPE_AUTO},
332 {"fixed", VNIC_MAC_ADDR_TYPE_PRIMARY},
333 {"vrrp", VNIC_MAC_ADDR_TYPE_VRID}
334 };
335
336 #define NADDR_TYPES (sizeof (addr_types) / sizeof (dladm_vnic_addr_type_t))
337
338 static const char *
dladm_vnic_macaddrtype2str(vnic_mac_addr_type_t type)339 dladm_vnic_macaddrtype2str(vnic_mac_addr_type_t type)
340 {
341 int i;
342
343 for (i = 0; i < NADDR_TYPES; i++) {
344 if (type == addr_types[i].va_type)
345 return (addr_types[i].va_str);
346 }
347 return (NULL);
348 }
349
350 dladm_status_t
dladm_vnic_str2macaddrtype(const char * str,vnic_mac_addr_type_t * val)351 dladm_vnic_str2macaddrtype(const char *str, vnic_mac_addr_type_t *val)
352 {
353 int i;
354 dladm_vnic_addr_type_t *type;
355
356 for (i = 0; i < NADDR_TYPES; i++) {
357 type = &addr_types[i];
358 if (strncmp(str, type->va_str, strlen(type->va_str)) == 0) {
359 *val = type->va_type;
360 return (DLADM_STATUS_OK);
361 }
362 }
363 return (DLADM_STATUS_BADARG);
364 }
365
366 /*
367 * Based on the VRRP specification, the virtual router MAC address associated
368 * with a virtual router is an IEEE 802 MAC address in the following format:
369 *
370 * IPv4 case: 00-00-5E-00-01-{VRID} (in hex in internet standard bit-order)
371 *
372 * IPv6 case: 00-00-5E-00-02-{VRID} (in hex in internet standard bit-order)
373 */
374 static dladm_status_t
i_dladm_vnic_vrrp_mac(vrid_t vrid,int af,uint8_t * mac,uint_t maclen)375 i_dladm_vnic_vrrp_mac(vrid_t vrid, int af, uint8_t *mac, uint_t maclen)
376 {
377 if (maclen < ETHERADDRL || vrid < VRRP_VRID_MIN ||
378 vrid > VRRP_VRID_MAX || (af != AF_INET && af != AF_INET6)) {
379 return (DLADM_STATUS_BADARG);
380 }
381
382 mac[0] = mac[1] = mac[3] = 0x0;
383 mac[2] = 0x5e;
384 mac[4] = (af == AF_INET) ? 0x01 : 0x02;
385 mac[5] = vrid;
386 return (DLADM_STATUS_OK);
387 }
388
389 /*
390 * Create a new VNIC / VLAN. Update the configuration file and bring it up.
391 * The "vrid" and "af" arguments are only required if the mac_addr_type is
392 * VNIC_MAC_ADDR_TYPE_VRID. In that case, the MAC address will be caculated
393 * based on the above algorithm.
394 */
395 dladm_status_t
dladm_vnic_create(dladm_handle_t handle,const char * vnic,datalink_id_t linkid,vnic_mac_addr_type_t mac_addr_type,uchar_t * mac_addr,uint_t mac_len,int * mac_slot,uint_t mac_prefix_len,uint16_t vid,vrid_t vrid,int af,datalink_id_t * vnic_id_out,dladm_arg_list_t * proplist,uint32_t flags)396 dladm_vnic_create(dladm_handle_t handle, const char *vnic, datalink_id_t linkid,
397 vnic_mac_addr_type_t mac_addr_type, uchar_t *mac_addr, uint_t mac_len,
398 int *mac_slot, uint_t mac_prefix_len, uint16_t vid, vrid_t vrid,
399 int af, datalink_id_t *vnic_id_out, dladm_arg_list_t *proplist,
400 uint32_t flags)
401 {
402 dladm_vnic_attr_t attr;
403 datalink_id_t vnic_id;
404 datalink_class_t class;
405 uint32_t media = DL_ETHER;
406 char name[MAXLINKNAMELEN];
407 uchar_t tmp_addr[MAXMACADDRLEN];
408 dladm_status_t status;
409 boolean_t is_vlan;
410 boolean_t is_etherstub;
411 int i;
412 boolean_t vnic_created = B_FALSE;
413 boolean_t conf_set = B_FALSE;
414
415 /*
416 * Sanity test arguments.
417 */
418 if ((flags & DLADM_OPT_ACTIVE) == 0)
419 return (DLADM_STATUS_NOTSUP);
420
421 is_vlan = ((flags & DLADM_OPT_VLAN) != 0);
422 if (is_vlan && ((vid < 1 || vid > 4094)))
423 return (DLADM_STATUS_VIDINVAL);
424
425 is_etherstub = (linkid == DATALINK_INVALID_LINKID);
426
427 if (!dladm_vnic_macaddrtype2str(mac_addr_type))
428 return (DLADM_STATUS_INVALIDMACADDRTYPE);
429
430 if ((flags & DLADM_OPT_ANCHOR) == 0) {
431 if ((status = dladm_datalink_id2info(handle, linkid, NULL,
432 &class, &media, NULL, 0)) != DLADM_STATUS_OK)
433 return (status);
434
435 if (class == DATALINK_CLASS_VNIC ||
436 class == DATALINK_CLASS_VLAN)
437 return (DLADM_STATUS_BADARG);
438 } else {
439 /* it's an anchor VNIC */
440 if (linkid != DATALINK_INVALID_LINKID || vid != 0)
441 return (DLADM_STATUS_BADARG);
442 }
443
444 /*
445 * Only VRRP VNIC need VRID and address family specified.
446 */
447 if (mac_addr_type != VNIC_MAC_ADDR_TYPE_VRID &&
448 (af != AF_UNSPEC || vrid != VRRP_VRID_NONE)) {
449 return (DLADM_STATUS_BADARG);
450 }
451
452 /*
453 * If a random address might be generated, but no prefix
454 * was specified by the caller, use the default MAC address
455 * prefix.
456 */
457 if ((mac_addr_type == VNIC_MAC_ADDR_TYPE_RANDOM ||
458 mac_addr_type == VNIC_MAC_ADDR_TYPE_AUTO) &&
459 mac_prefix_len == 0) {
460 mac_prefix_len = sizeof (dladm_vnic_def_prefix);
461 mac_addr = tmp_addr;
462 bcopy(dladm_vnic_def_prefix, mac_addr, mac_prefix_len);
463 }
464
465 /*
466 * If this is a VRRP VNIC, generate its MAC address using the given
467 * VRID and address family.
468 */
469 if (mac_addr_type == VNIC_MAC_ADDR_TYPE_VRID) {
470 /*
471 * VRRP VNICs must be created over ethernet data-links.
472 */
473 if (vrid < VRRP_VRID_MIN || vrid > VRRP_VRID_MAX ||
474 (af != AF_INET && af != AF_INET6) || mac_addr != NULL ||
475 mac_len != 0 || mac_prefix_len != 0 ||
476 (mac_slot != NULL && *mac_slot != -1) || is_etherstub ||
477 media != DL_ETHER) {
478 return (DLADM_STATUS_BADARG);
479 }
480 mac_len = ETHERADDRL;
481 mac_addr = tmp_addr;
482 status = i_dladm_vnic_vrrp_mac(vrid, af, mac_addr, mac_len);
483 if (status != DLADM_STATUS_OK)
484 return (status);
485 }
486
487 if (mac_len > MAXMACADDRLEN)
488 return (DLADM_STATUS_INVALIDMACADDRLEN);
489
490 if (vnic == NULL) {
491 flags |= DLADM_OPT_PREFIX;
492 (void) strlcpy(name, "vnic", sizeof (name));
493 } else {
494 (void) strlcpy(name, vnic, sizeof (name));
495 }
496
497 class = is_vlan ? DATALINK_CLASS_VLAN :
498 (is_etherstub ? DATALINK_CLASS_ETHERSTUB : DATALINK_CLASS_VNIC);
499 if ((status = dladm_create_datalink_id(handle, name, class,
500 media, flags, &vnic_id)) != DLADM_STATUS_OK)
501 return (status);
502
503 if ((flags & DLADM_OPT_PREFIX) != 0) {
504 (void) snprintf(name + 4, sizeof (name), "%llu", vnic_id);
505 flags &= ~DLADM_OPT_PREFIX;
506 }
507
508 bzero(&attr, sizeof (attr));
509
510 /* Extract resource_ctl and cpu_list from proplist */
511 if (proplist != NULL) {
512 status = dladm_link_proplist_extract(handle, proplist,
513 &attr.va_resource_props, 0);
514 if (status != DLADM_STATUS_OK)
515 goto done;
516 }
517
518 attr.va_vnic_id = vnic_id;
519 attr.va_link_id = linkid;
520 attr.va_mac_addr_type = mac_addr_type;
521 attr.va_mac_len = mac_len;
522 if (mac_slot != NULL)
523 attr.va_mac_slot = *mac_slot;
524 if (mac_len > 0)
525 bcopy(mac_addr, attr.va_mac_addr, mac_len);
526 else if (mac_prefix_len > 0)
527 bcopy(mac_addr, attr.va_mac_addr, mac_prefix_len);
528 attr.va_mac_prefix_len = mac_prefix_len;
529 attr.va_vid = vid;
530 attr.va_vrid = vrid;
531 attr.va_af = af;
532 attr.va_force = (flags & DLADM_OPT_FORCE) != 0;
533
534 status = i_dladm_vnic_create_sys(handle, &attr);
535 if (status != DLADM_STATUS_OK)
536 goto done;
537 vnic_created = B_TRUE;
538
539 /* Save vnic configuration and its properties */
540 if (!(flags & DLADM_OPT_PERSIST))
541 goto done;
542
543 status = dladm_vnic_persist_conf(handle, name, &attr, class);
544 if (status != DLADM_STATUS_OK)
545 goto done;
546 conf_set = B_TRUE;
547
548 if (proplist != NULL) {
549 for (i = 0; i < proplist->al_count; i++) {
550 dladm_arg_info_t *aip = &proplist->al_info[i];
551
552 status = dladm_set_linkprop(handle, vnic_id,
553 aip->ai_name, aip->ai_val, aip->ai_count,
554 DLADM_OPT_PERSIST);
555 if (status != DLADM_STATUS_OK)
556 break;
557 }
558 }
559
560 done:
561 if (status != DLADM_STATUS_OK) {
562 if (conf_set)
563 (void) dladm_remove_conf(handle, vnic_id);
564 if (vnic_created)
565 (void) i_dladm_vnic_delete_sys(handle, vnic_id);
566 (void) dladm_destroy_datalink_id(handle, vnic_id, flags);
567 } else {
568 if (vnic_id_out != NULL)
569 *vnic_id_out = vnic_id;
570 if (mac_slot != NULL)
571 *mac_slot = attr.va_mac_slot;
572 }
573
574 if (is_vlan) {
575 dladm_status_t stat2;
576
577 stat2 = dladm_bridge_refresh(handle, linkid);
578 if (status == DLADM_STATUS_OK && stat2 != DLADM_STATUS_OK)
579 status = stat2;
580 }
581 return (status);
582 }
583
584 /*
585 * Delete a VNIC / VLAN.
586 */
587 dladm_status_t
dladm_vnic_delete(dladm_handle_t handle,datalink_id_t linkid,uint32_t flags)588 dladm_vnic_delete(dladm_handle_t handle, datalink_id_t linkid, uint32_t flags)
589 {
590 dladm_status_t status;
591 datalink_class_t class;
592
593 if (flags == 0)
594 return (DLADM_STATUS_BADARG);
595
596 if ((dladm_datalink_id2info(handle, linkid, NULL, &class, NULL, NULL, 0)
597 != DLADM_STATUS_OK))
598 return (DLADM_STATUS_BADARG);
599
600 if ((flags & DLADM_OPT_VLAN) != 0) {
601 if (class != DATALINK_CLASS_VLAN)
602 return (DLADM_STATUS_BADARG);
603 } else {
604 if (class != DATALINK_CLASS_VNIC &&
605 class != DATALINK_CLASS_ETHERSTUB)
606 return (DLADM_STATUS_BADARG);
607 }
608
609 if ((flags & DLADM_OPT_ACTIVE) != 0) {
610 status = i_dladm_vnic_delete_sys(handle, linkid);
611 if (status == DLADM_STATUS_OK) {
612 (void) dladm_set_linkprop(handle, linkid, NULL, NULL, 0,
613 DLADM_OPT_ACTIVE);
614 (void) dladm_destroy_datalink_id(handle, linkid,
615 DLADM_OPT_ACTIVE);
616 } else if (status != DLADM_STATUS_NOTFOUND ||
617 !(flags & DLADM_OPT_PERSIST)) {
618 return (status);
619 }
620 }
621 if ((flags & DLADM_OPT_PERSIST) != 0) {
622 (void) dladm_remove_conf(handle, linkid);
623 (void) dladm_destroy_datalink_id(handle, linkid,
624 DLADM_OPT_PERSIST);
625 }
626 return (dladm_bridge_refresh(handle, linkid));
627 }
628
629 static const char *
dladm_vnic_macaddr2str(const uchar_t * mac,char * buf)630 dladm_vnic_macaddr2str(const uchar_t *mac, char *buf)
631 {
632 static char unknown_mac[] = {0, 0, 0, 0, 0, 0};
633
634 if (buf == NULL)
635 return (NULL);
636
637 if (bcmp(unknown_mac, mac, ETHERADDRL) == 0)
638 (void) strlcpy(buf, "unknown", DLADM_STRSIZE);
639 else
640 return (_link_ntoa(mac, buf, ETHERADDRL, IFT_OTHER));
641
642 return (buf);
643 }
644
645 static dladm_status_t
dladm_vnic_str2macaddr(const char * str,uchar_t * buf)646 dladm_vnic_str2macaddr(const char *str, uchar_t *buf)
647 {
648 int len = 0;
649 uchar_t *b = _link_aton(str, &len);
650
651 if (b == NULL || len >= MAXMACADDRLEN)
652 return (DLADM_STATUS_BADARG);
653
654 bcopy(b, buf, len);
655 free(b);
656 return (DLADM_STATUS_OK);
657 }
658
659
660 static dladm_status_t
dladm_vnic_persist_conf(dladm_handle_t handle,const char * name,dladm_vnic_attr_t * attrp,datalink_class_t class)661 dladm_vnic_persist_conf(dladm_handle_t handle, const char *name,
662 dladm_vnic_attr_t *attrp, datalink_class_t class)
663 {
664 dladm_conf_t conf;
665 dladm_status_t status;
666 char macstr[ETHERADDRL * 3];
667 char linkover[MAXLINKNAMELEN];
668 uint64_t u64;
669
670 if ((status = dladm_create_conf(handle, name, attrp->va_vnic_id,
671 class, DL_ETHER, &conf)) != DLADM_STATUS_OK)
672 return (status);
673
674 if (attrp->va_link_id != DATALINK_INVALID_LINKID) {
675 status = dladm_datalink_id2info(handle, attrp->va_link_id, NULL,
676 NULL, NULL, linkover, sizeof (linkover));
677 if (status != DLADM_STATUS_OK)
678 goto done;
679 status = dladm_set_conf_field(handle, conf, FLINKOVER,
680 DLADM_TYPE_STR, linkover);
681 if (status != DLADM_STATUS_OK)
682 goto done;
683 }
684
685 if (class != DATALINK_CLASS_VLAN) {
686 u64 = attrp->va_mac_addr_type;
687 status = dladm_set_conf_field(handle, conf, FMADDRTYPE,
688 DLADM_TYPE_UINT64, &u64);
689 if (status != DLADM_STATUS_OK)
690 goto done;
691
692 u64 = attrp->va_vrid;
693 status = dladm_set_conf_field(handle, conf, FVRID,
694 DLADM_TYPE_UINT64, &u64);
695 if (status != DLADM_STATUS_OK)
696 goto done;
697
698 u64 = attrp->va_af;
699 status = dladm_set_conf_field(handle, conf, FVRAF,
700 DLADM_TYPE_UINT64, &u64);
701 if (status != DLADM_STATUS_OK)
702 goto done;
703
704 if (attrp->va_mac_len != ETHERADDRL) {
705 u64 = attrp->va_mac_len;
706 status = dladm_set_conf_field(handle, conf, FMADDRLEN,
707 DLADM_TYPE_UINT64, &u64);
708 if (status != DLADM_STATUS_OK)
709 goto done;
710 }
711
712 if (attrp->va_mac_slot != -1) {
713 u64 = attrp->va_mac_slot;
714 status = dladm_set_conf_field(handle, conf,
715 FMADDRSLOT, DLADM_TYPE_UINT64, &u64);
716 if (status != DLADM_STATUS_OK)
717 goto done;
718 }
719
720 if (attrp->va_mac_prefix_len !=
721 sizeof (dladm_vnic_def_prefix)) {
722 u64 = attrp->va_mac_prefix_len;
723 status = dladm_set_conf_field(handle, conf,
724 FMADDRPREFIXLEN, DLADM_TYPE_UINT64, &u64);
725 if (status != DLADM_STATUS_OK)
726 goto done;
727 }
728
729 (void) dladm_vnic_macaddr2str(attrp->va_mac_addr, macstr);
730 status = dladm_set_conf_field(handle, conf, FMACADDR,
731 DLADM_TYPE_STR, macstr);
732 if (status != DLADM_STATUS_OK)
733 goto done;
734 }
735
736 if (attrp->va_vid != 0) {
737 u64 = attrp->va_vid;
738 status = dladm_set_conf_field(handle, conf, FVLANID,
739 DLADM_TYPE_UINT64, &u64);
740 if (status != DLADM_STATUS_OK)
741 goto done;
742 }
743
744 /*
745 * Commit the link configuration.
746 */
747 status = dladm_write_conf(handle, conf);
748
749 done:
750 dladm_destroy_conf(handle, conf);
751 return (status);
752 }
753
754 typedef struct dladm_vnic_up_arg_s {
755 uint32_t flags;
756 dladm_status_t status;
757 } dladm_vnic_up_arg_t;
758
759 static int
i_dladm_vnic_up(dladm_handle_t handle,datalink_id_t linkid,void * arg)760 i_dladm_vnic_up(dladm_handle_t handle, datalink_id_t linkid, void *arg)
761 {
762 dladm_status_t *statusp = &(((dladm_vnic_up_arg_t *)arg)->status);
763 dladm_vnic_attr_t attr;
764 dladm_status_t status;
765 dladm_arg_list_t *proplist;
766
767 bzero(&attr, sizeof (attr));
768
769 status = dladm_vnic_info(handle, linkid, &attr, DLADM_OPT_PERSIST);
770 if (status != DLADM_STATUS_OK)
771 goto done;
772
773 /* Get all properties for this vnic */
774 status = dladm_link_get_proplist(handle, linkid, &proplist);
775 if (status != DLADM_STATUS_OK)
776 goto done;
777
778 if (proplist != NULL) {
779 status = dladm_link_proplist_extract(handle, proplist,
780 &attr.va_resource_props, DLADM_OPT_BOOT);
781 }
782
783 status = i_dladm_vnic_create_sys(handle, &attr);
784 if (status == DLADM_STATUS_OK) {
785 status = dladm_up_datalink_id(handle, linkid);
786 if (status != DLADM_STATUS_OK)
787 (void) i_dladm_vnic_delete_sys(handle, linkid);
788 }
789
790 done:
791 *statusp = status;
792 return (DLADM_WALK_CONTINUE);
793 }
794
795 dladm_status_t
dladm_vnic_up(dladm_handle_t handle,datalink_id_t linkid,uint32_t flags)796 dladm_vnic_up(dladm_handle_t handle, datalink_id_t linkid, uint32_t flags)
797 {
798 dladm_vnic_up_arg_t vnic_arg;
799 datalink_class_t class;
800
801 class = ((flags & DLADM_OPT_VLAN) != 0) ? DATALINK_CLASS_VLAN :
802 (DATALINK_CLASS_VNIC | DATALINK_CLASS_ETHERSTUB);
803
804 if (linkid == DATALINK_ALL_LINKID) {
805 (void) dladm_walk_datalink_id(i_dladm_vnic_up, handle,
806 &vnic_arg, class, DATALINK_ANY_MEDIATYPE,
807 DLADM_OPT_PERSIST);
808 return (DLADM_STATUS_OK);
809 } else {
810 (void) i_dladm_vnic_up(handle, linkid, &vnic_arg);
811 return (vnic_arg.status);
812 }
813 }
814