2 * Copyright (c) 2015 Nicira, Inc.
3 * Copyright (c) 2014 WindRiver, Inc.
4 * Copyright (c) 2015 Avaya, Inc.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
19 /* Implementation of Auto Attach.
20 * Based on sample implementation in 802.1ab. Above copyright and license
21 * applies to all modifications.
23 * - No support for multiple bridge.
24 * - Auto Attach state machine not implemented.
25 * - Auto Attach and LLDP code are bundled together. The plan is to decoupled
31 #include <arpa/inet.h>
33 #include <netinet/in.h>
36 #include <sys/types.h>
37 #include "openvswitch/dynamic-string.h"
39 #include "openvswitch/list.h"
40 #include "lldp/lldpd.h"
41 #include "lldp/lldpd-structs.h"
43 #include "openvswitch/types.h"
45 #include "poll-loop.h"
49 #include "openvswitch/vlog.h"
51 VLOG_DEFINE_THIS_MODULE(ovs_lldp);
53 #define LLDP_PROTOCOL_ID 0x0000
54 #define LLDP_PROTOCOL_VERSION 0x00
55 #define LLDP_TYPE_CONFIG 0x00
56 #define LLDP_CHASSIS_TTL 120
57 #define ETH_TYPE_LLDP 0x88cc
58 #define MINIMUM_ETH_PACKET_SIZE 68
60 #define AA_STATUS_MULTIPLE \
61 AA_STATUS(ACTIVE,2,Active) \
62 AA_STATUS(REJECT_GENERIC,3,Reject (Generic)) \
63 AA_STATUS(REJECT_AA_RES_NOTAVAIL,4,Reject (AA resources unavailable)) \
64 AA_STATUS(REJECT_INVALID,6,Reject (Invalid)) \
65 AA_STATUS(REJECT_VLAN_RES_UNAVAIL,8,Reject (VLAN resources unavailable)) \
66 AA_STATUS(REJECT_VLAN_APP_ISSUE,9,Reject (Application interaction issue)) \
67 AA_STATUS(PENDING,255,Pending)
70 #define AA_STATUS(NAME, VALUE, STR) AA_STATUS_##NAME = VALUE,
76 /* Internal structure for an Auto Attach mapping.
78 struct aa_mapping_internal {
79 struct hmap_node hmap_node_isid;
80 struct hmap_node hmap_node_aux;
84 enum aa_status status;
87 static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
89 /* Hash map of all LLDP instances keyed by name (port at the moment).
91 static struct hmap all_lldps__ = HMAP_INITIALIZER(&all_lldps__);
92 static struct hmap *const all_lldps OVS_GUARDED_BY(mutex) = &all_lldps__;
94 /* Hash map of all the Auto Attach mappings. Global at the moment (but will
95 * be per bridge). Used when adding a new port to a bridge so that we can
96 * properly install all the configured mapping on the port and export them
97 * To the Auto Attach server via LLDP.
99 static struct hmap all_mappings__ = HMAP_INITIALIZER(&all_mappings__);
100 static struct hmap *const all_mappings OVS_GUARDED_BY(mutex) = &all_mappings__;
102 static struct lldp_aa_element_system_id system_id_null;
104 /* Convert an LLDP chassis ID to a string.
107 chassisid_to_string(uint8_t *array, size_t len, char **str)
111 *str = xmalloc(len * 3);
113 for (i = 0; i < len; i++) {
114 snprintf(&(*str)[i * 3], 4, "%02x:", array[i]);
116 (*str)[(i * 3) - 1] = '\0';
119 /* Find an Auto Attach mapping keyed by I-SID.
121 static struct aa_mapping_internal *
122 mapping_find_by_isid(struct lldp *lldp, uint32_t isid)
125 struct aa_mapping_internal *m;
127 HMAP_FOR_EACH_IN_BUCKET (m, hmap_node_isid, hash_int(isid, 0),
128 &lldp->mappings_by_isid) {
129 if (isid == m->isid) {
137 /* Find an Auto Attach mapping keyed by aux. aux is an opaque pointer created
138 * by the bridge that refers to an OVSDB mapping record.
140 static struct aa_mapping_internal *
141 mapping_find_by_aux(struct lldp *lldp, const void *aux) OVS_REQUIRES(mutex)
143 struct aa_mapping_internal *m;
145 HMAP_FOR_EACH_IN_BUCKET (m, hmap_node_aux, hash_pointer(aux, 0),
146 &lldp->mappings_by_aux) {
155 /* Convert an Auto Attach request status to a string.
158 aa_status_to_str(uint8_t status)
161 #define AA_STATUS(NAME, VALUE, STR) case AA_STATUS_##NAME: return #STR;
164 default: return "Undefined";
168 /* Display LLDP and Auto Attach statistics.
171 aa_print_lldp_and_aa_stats(struct ds *ds, struct lldp *lldp)
174 struct lldpd_hardware *hw;
176 ds_put_format(ds, "Statistics: %s\n", lldp->name);
182 LIST_FOR_EACH (hw, h_entries, &lldp->lldpd->g_hardware) {
183 ds_put_format(ds, "\ttx cnt: %"PRIu64"\n", hw->h_tx_cnt);
184 ds_put_format(ds, "\trx cnt: %"PRIu64"\n", hw->h_rx_cnt);
185 ds_put_format(ds, "\trx discarded cnt: %"PRIu64"\n",
186 hw->h_rx_discarded_cnt);
187 ds_put_format(ds, "\trx unrecognized cnt: %"PRIu64"\n",
188 hw->h_rx_unrecognized_cnt);
189 ds_put_format(ds, "\tageout cnt: %"PRIu64"\n", hw->h_ageout_cnt);
190 ds_put_format(ds, "\tinsert cnt: %"PRIu64"\n", hw->h_insert_cnt);
191 ds_put_format(ds, "\tdelete cnt: %"PRIu64"\n", hw->h_delete_cnt);
192 ds_put_format(ds, "\tdrop cnt: %"PRIu64"\n", hw->h_drop_cnt);
197 aa_print_element_status_port(struct ds *ds, struct lldpd_hardware *hw)
199 struct lldpd_port *port;
201 LIST_FOR_EACH (port, p_entries, &hw->h_rports) {
202 if (memcmp(&port->p_element.system_id,
204 sizeof port->p_element.system_id)) {
205 const char *none_str = "<None>";
206 const char *descr = NULL;
210 if (port->p_chassis) {
211 if (port->p_chassis->c_id_len > 0) {
212 chassisid_to_string(port->p_chassis->c_id,
213 port->p_chassis->c_id_len, &id);
216 descr = port->p_chassis->c_descr;
219 chassisid_to_string((uint8_t *) &port->p_element.system_id,
220 sizeof port->p_element.system_id, &system);
222 ds_put_format(ds, "\tAuto Attach Primary Server Id: %s\n",
224 ds_put_format(ds, "\tAuto Attach Primary Server Descr: %s\n",
225 descr ? descr : none_str);
226 ds_put_format(ds, "\tAuto Attach Primary Server System Id: %s\n",
235 /* Auto Attach server broadcast an LLDP message periodically. Display
236 * the discovered server.
239 aa_print_element_status(struct ds *ds, struct lldp *lldp) OVS_REQUIRES(mutex)
241 struct lldpd_hardware *hw;
243 ds_put_format(ds, "LLDP: %s\n", lldp->name);
249 LIST_FOR_EACH (hw, h_entries, &lldp->lldpd->g_hardware) {
250 aa_print_element_status_port(ds, hw);
255 aa_print_isid_status_port_isid(struct lldp *lldp, struct lldpd_port *port)
258 struct lldpd_aa_isid_vlan_maps_tlv *mapping;
260 if (ovs_list_is_empty(&port->p_isid_vlan_maps)) {
264 LIST_FOR_EACH (mapping, m_entries, &port->p_isid_vlan_maps) {
265 uint32_t isid = mapping->isid_vlan_data.isid;
266 struct aa_mapping_internal *m = mapping_find_by_isid(lldp, isid);
268 VLOG_INFO("h_rport: isid=%u, vlan=%u, status=%d",
270 mapping->isid_vlan_data.vlan,
271 mapping->isid_vlan_data.status);
273 /* Update the status of our internal state for the mapping. */
275 VLOG_INFO("Setting status for ISID=%"PRIu32" to %"PRIu16,
276 isid, mapping->isid_vlan_data.status);
277 m->status = mapping->isid_vlan_data.status;
279 VLOG_WARN("Couldn't find mapping for I-SID=%"PRIu32, isid);
285 aa_print_isid_status_port(struct lldp *lldp, struct lldpd_hardware *hw)
288 struct lldpd_port *port;
290 LIST_FOR_EACH (port, p_entries, &hw->h_rports) {
291 aa_print_isid_status_port_isid(lldp, port);
295 /* The Auto Attach server will broadcast the status of the configured mappings
296 * via LLDP. Display the status.
299 aa_print_isid_status(struct ds *ds, struct lldp *lldp) OVS_REQUIRES(mutex)
301 struct lldpd_hardware *hw;
302 struct aa_mapping_internal *m;
308 ds_put_format(ds, "LLDP: %s\n", lldp->name);
310 LIST_FOR_EACH (hw, h_entries, &lldp->lldpd->g_hardware) {
311 aa_print_isid_status_port(lldp, hw);
314 ds_put_format(ds, "%-8s %-4s %-11s %-8s\n",
319 ds_put_format(ds, "-------- ---- ----------- --------\n");
321 HMAP_FOR_EACH (m, hmap_node_isid, &lldp->mappings_by_isid) {
322 ds_put_format(ds, "%-8"PRIu32" %-4"PRIu16" %-11s %-11s\n",
323 m->isid, m->vlan, "Switch", aa_status_to_str(m->status));
328 aa_unixctl_status(struct unixctl_conn *conn, int argc OVS_UNUSED,
329 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
333 struct ds ds = DS_EMPTY_INITIALIZER;
335 ovs_mutex_lock(&mutex);
337 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
338 aa_print_element_status(&ds, lldp);
340 unixctl_command_reply(conn, ds_cstr(&ds));
343 ovs_mutex_unlock(&mutex);
347 aa_unixctl_show_isid(struct unixctl_conn *conn, int argc OVS_UNUSED,
348 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
352 struct ds ds = DS_EMPTY_INITIALIZER;
354 ovs_mutex_lock(&mutex);
356 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
357 aa_print_isid_status(&ds, lldp);
359 unixctl_command_reply(conn, ds_cstr(&ds));
362 ovs_mutex_unlock(&mutex);
366 aa_unixctl_statistics(struct unixctl_conn *conn, int argc OVS_UNUSED,
367 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
370 struct ds ds = DS_EMPTY_INITIALIZER;
373 ovs_mutex_lock(&mutex);
375 /* Cycle through all ports and dump the stats for each one */
376 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
377 aa_print_lldp_and_aa_stats(&ds, lldp);
380 ovs_mutex_unlock(&mutex);
382 unixctl_command_reply(conn, ds_cstr(&ds));
385 /* An Auto Attach mapping was configured. Populate the corresponding
386 * structures in the LLDP hardware.
389 update_mapping_on_lldp(struct lldp *lldp, struct lldpd_hardware *hardware,
390 struct aa_mapping_internal *m)
392 struct lldpd_aa_isid_vlan_maps_tlv *lm = xzalloc(sizeof *lm);
394 VLOG_INFO("\t\t hardware->h_ifname=%s", hardware->h_ifname);
396 lm->isid_vlan_data.isid = m->isid;
397 lm->isid_vlan_data.vlan = m->vlan;
399 ovs_list_push_back(&hardware->h_lport.p_isid_vlan_maps, &lm->m_entries);
401 /* TODO Should be done in the Auto Attach state machine when a mapping goes
402 * from "pending" to "active".
404 struct bridge_aa_vlan *node = xmalloc(sizeof *node);
406 node->port_name = xstrdup(hardware->h_ifname);
407 node->vlan = m->vlan;
408 node->oper = BRIDGE_AA_VLAN_OPER_ADD;
410 ovs_list_push_back(&lldp->active_mapping_queue, &node->list_node);
413 /* Bridge will poll the list of VLAN that needs to be auto configure based on
414 * the Auto Attach mappings that have been exchanged with the server.
417 aa_get_vlan_queued(struct ovs_list *list)
421 ovs_mutex_lock(&mutex);
423 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
424 struct bridge_aa_vlan *node;
426 LIST_FOR_EACH_POP (node, list_node, &lldp->active_mapping_queue) {
427 struct bridge_aa_vlan *copy;
429 copy = xmalloc(sizeof *copy);
430 copy->port_name = xstrdup(node->port_name);
431 copy->vlan = node->vlan;
432 copy->oper = node->oper;
434 ovs_list_push_back(list, ©->list_node);
437 free(node->port_name);
442 ovs_mutex_unlock(&mutex);
447 /* Bridge will poll whether or not VLAN have been auto-configured.
450 aa_get_vlan_queue_size(void)
453 unsigned int size = 0;
455 ovs_mutex_lock(&mutex);
457 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
458 size += ovs_list_size(&lldp->active_mapping_queue);
461 ovs_mutex_unlock(&mutex);
466 /* Configure Auto Attach.
469 aa_configure(const struct aa_settings *s)
473 ovs_mutex_lock(&mutex);
475 /* TODO Change all instances for now */
476 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
477 struct lldpd_chassis *chassis;
479 LIST_FOR_EACH (chassis, list, &lldp->lldpd->g_chassis) {
480 /* System Description */
481 free(chassis->c_descr);
482 chassis->c_descr = s && s->system_description[0] ?
483 xstrdup(s->system_description) : xstrdup(PACKAGE_STRING);
487 free(chassis->c_name);
488 chassis->c_name = xstrdup(s->system_name);
493 ovs_mutex_unlock(&mutex);
498 /* Add a new Auto Attach mapping.
501 aa_mapping_register(void *aux, const struct aa_mapping_settings *s)
503 struct aa_mapping_internal *bridge_m;
506 VLOG_INFO("Adding mapping ISID=%"PRIu32", VLAN=%"PRIu16", aux=%p",
507 s->isid, s->vlan, aux);
509 ovs_mutex_lock(&mutex);
511 /* TODO These mappings should be stores per bridge. This is used
512 * When a port is added. Auto Attach mappings need to be added on this
515 bridge_m = xzalloc(sizeof *bridge_m);
516 bridge_m->isid = s->isid;
517 bridge_m->vlan = s->vlan;
519 bridge_m->status = AA_STATUS_PENDING;
520 hmap_insert(all_mappings, &bridge_m->hmap_node_isid,
521 hash_int(bridge_m->isid, 0));
524 /* Update mapping on the all the LLDP instances. */
525 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
526 struct lldpd_hardware *hw;
527 struct aa_mapping_internal *m;
529 VLOG_INFO("\t lldp->name=%s", lldp->name);
531 if (mapping_find_by_isid(lldp, s->isid)) {
535 m = xzalloc(sizeof *m);
538 m->status = AA_STATUS_PENDING;
540 hmap_insert(&lldp->mappings_by_isid, &m->hmap_node_isid,
541 hash_int(m->isid, 0));
542 hmap_insert(&lldp->mappings_by_aux,
544 hash_pointer(m->aux, 0));
546 /* Configure the mapping on each port of the LLDP stack. */
547 LIST_FOR_EACH (hw, h_entries, &lldp->lldpd->g_hardware) {
548 update_mapping_on_lldp(lldp, hw, m);
552 ovs_mutex_unlock(&mutex);
558 aa_mapping_unregister_mapping(struct lldp *lldp,
559 struct lldpd_hardware *hw,
560 struct aa_mapping_internal *m)
562 struct lldpd_aa_isid_vlan_maps_tlv *lm, *lm_next;
564 LIST_FOR_EACH_SAFE (lm, lm_next, m_entries,
565 &hw->h_lport.p_isid_vlan_maps) {
566 uint32_t isid = lm->isid_vlan_data.isid;
568 if (isid == m->isid) {
569 VLOG_INFO("\t\t Removing lport, isid=%u, vlan=%u",
571 lm->isid_vlan_data.vlan);
573 ovs_list_remove(&lm->m_entries);
575 /* TODO Should be done in the AA SM when a mapping goes
576 * from "pending" to "active".
578 struct bridge_aa_vlan *node = xmalloc(sizeof *node);
580 node->port_name = xstrdup(hw->h_ifname);
581 node->vlan = m->vlan;
582 node->oper = BRIDGE_AA_VLAN_OPER_REMOVE;
584 ovs_list_push_back(&lldp->active_mapping_queue, &node->list_node);
591 /* Remove an existing Auto Attach mapping.
594 aa_mapping_unregister(void *aux)
598 VLOG_INFO("Removing mapping aux=%p", aux);
600 ovs_mutex_lock(&mutex);
602 HMAP_FOR_EACH (lldp, hmap_node, all_lldps) {
603 struct lldpd_hardware *hw;
604 struct aa_mapping_internal *m = mapping_find_by_aux(lldp, aux);
606 /* Remove from internal hash tables. */
608 uint32_t isid = m->isid;
609 uint16_t vlan = m->vlan;
610 struct aa_mapping_internal *p = mapping_find_by_isid(lldp, isid);
612 VLOG_INFO("\t Removing mapping ISID=%"PRIu32", VLAN=%"PRIu16
613 " (lldp->name=%s)", isid, vlan, lldp->name);
616 hmap_remove(&lldp->mappings_by_isid, &p->hmap_node_isid);
619 hmap_remove(&lldp->mappings_by_aux, &m->hmap_node_aux);
621 /* Remove from all the lldp instances */
622 LIST_FOR_EACH (hw, h_entries, &lldp->lldpd->g_hardware) {
623 VLOG_INFO("\t\t hardware->h_ifname=%s", hw->h_ifname);
624 aa_mapping_unregister_mapping(lldp, hw, m);
628 /* Remove from the all_mappings */
629 HMAP_FOR_EACH (m, hmap_node_isid, all_mappings) {
630 if (m && isid == m->isid && vlan == m->vlan) {
631 hmap_remove(all_mappings, &m->hmap_node_isid);
638 ovs_mutex_unlock(&mutex);
646 unixctl_command_register("autoattach/status", "[bridge]", 0, 1,
647 aa_unixctl_status, NULL);
648 unixctl_command_register("autoattach/show-isid", "[bridge]", 0, 1,
649 aa_unixctl_show_isid, NULL);
650 unixctl_command_register("autoattach/statistics", "[bridge]", 0, 1,
651 aa_unixctl_statistics, NULL);
654 /* Returns true if 'lldp' should process packets from 'flow'. Sets
655 * fields in 'wc' that were used to make the determination.
658 lldp_should_process_flow(struct lldp *lldp, const struct flow *flow)
660 return (flow->dl_type == htons(ETH_TYPE_LLDP) && lldp->enabled);
664 /* Process an LLDP packet that was received on a bridge port.
667 lldp_process_packet(struct lldp *lldp, const struct dp_packet *p)
670 lldpd_recv(lldp->lldpd, lldpd_first_hardware(lldp->lldpd),
671 (char *) dp_packet_data(p), dp_packet_size(p));
675 /* This code is called periodically to check if the LLDP module has an LLDP
676 * message it wishes to send. It is called several times every second.
679 lldp_should_send_packet(struct lldp *cfg) OVS_EXCLUDED(mutex)
683 ovs_mutex_lock(&mutex);
684 ret = timer_expired(&cfg->tx_timer);
685 ovs_mutex_unlock(&mutex);
687 /* LLDP must be enabled */
693 /* Returns the next wake up time.
696 lldp_wake_time(const struct lldp *lldp) OVS_EXCLUDED(mutex)
698 long long int retval;
700 if (!lldp || !lldp->enabled) {
704 ovs_mutex_lock(&mutex);
705 retval = lldp->tx_timer.t;
706 ovs_mutex_unlock(&mutex);
711 /* Put the monitor thread to sleep until it's next wake time.
714 lldp_wait(struct lldp *lldp) OVS_EXCLUDED(mutex)
716 long long int wake_time = lldp_wake_time(lldp);
717 poll_timer_wait_until(wake_time);
721 /* Prepare the LLDP packet to be sent on a bridge port.
724 lldp_put_packet(struct lldp *lldp, struct dp_packet *packet,
725 const struct eth_addr eth_src) OVS_EXCLUDED(mutex)
727 struct lldpd *mylldpd = lldp->lldpd;
728 struct lldpd_hardware *hw = lldpd_first_hardware(mylldpd);
729 static const struct eth_addr eth_addr_lldp =
730 { { { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x0e } } };
732 ovs_mutex_lock(&mutex);
734 eth_compose(packet, eth_addr_lldp, eth_src, ETH_TYPE_LLDP, 0);
736 lldpd_send(hw, packet);
738 timer_set_duration(&lldp->tx_timer, lldp->lldpd->g_config.c_tx_interval);
739 ovs_mutex_unlock(&mutex);
742 /* Configures the LLDP stack.
745 lldp_configure(struct lldp *lldp, const struct smap *cfg) OVS_EXCLUDED(mutex)
748 if (cfg && smap_get_bool(cfg, "enable", false)) {
749 lldp->enabled = true;
751 lldp->enabled = false;
754 ovs_mutex_lock(&mutex);
755 timer_set_expired(&lldp->tx_timer);
756 timer_set_duration(&lldp->tx_timer, LLDP_DEFAULT_TRANSMIT_INTERVAL_MS);
757 lldp->lldpd->g_config.c_tx_interval =
758 LLDP_DEFAULT_TRANSMIT_INTERVAL_MS;
759 ovs_mutex_unlock(&mutex);
765 /* Create an LLDP stack instance. At the moment there is one per bridge port.
768 lldp_create(const struct netdev *netdev,
770 const struct smap *cfg) OVS_EXCLUDED(mutex)
773 struct lldpd_chassis *lchassis;
774 struct lldpd_hardware *hw;
775 struct aa_mapping_internal *m;
777 if (!cfg || !smap_get_bool(cfg, "enable", false)) {
781 lldp = xzalloc(sizeof *lldp);
782 lldp->name = xstrdup(netdev_get_name(netdev));
783 lldp->lldpd = xzalloc(sizeof *lldp->lldpd);
785 hmap_init(&lldp->mappings_by_isid);
786 hmap_init(&lldp->mappings_by_aux);
787 ovs_list_init(&lldp->active_mapping_queue);
789 lchassis = xzalloc(sizeof *lchassis);
790 lchassis->c_cap_available = LLDP_CAP_BRIDGE;
791 lchassis->c_cap_enabled = LLDP_CAP_BRIDGE;
792 lchassis->c_id_subtype = LLDP_CHASSISID_SUBTYPE_LLADDR;
793 lchassis->c_id_len = ETH_ADDR_LEN;
795 struct eth_addr *mac = xmalloc(ETH_ADDR_LEN);
796 netdev_get_etheraddr(netdev, mac);
797 lchassis->c_id = &mac->ea[0];
799 ovs_list_init(&lchassis->c_mgmt);
800 lchassis->c_ttl = lldp->lldpd->g_config.c_tx_interval *
801 lldp->lldpd->g_config.c_tx_hold;
802 lchassis->c_ttl = LLDP_CHASSIS_TTL;
803 lldpd_assign_cfg_to_protocols(lldp->lldpd);
804 ovs_list_init(&lldp->lldpd->g_chassis);
805 ovs_list_push_back(&lldp->lldpd->g_chassis, &lchassis->list);
807 if ((hw = lldpd_alloc_hardware(lldp->lldpd,
808 (char *) netdev_get_name(netdev),
810 VLOG_WARN("Unable to allocate space for %s",
811 (char *) netdev_get_name(netdev));
815 ovs_refcount_init(&lldp->ref_cnt);
817 hw->h_flags |= IFF_RUNNING;
820 hw->h_lport.p_id_subtype = LLDP_PORTID_SUBTYPE_IFNAME;
821 hw->h_lport.p_id = xstrdup(netdev_get_name(netdev));
823 /* p_id is not necessarily a null terminated string. */
824 hw->h_lport.p_id_len = strlen(netdev_get_name(netdev));
826 /* Auto Attach element tlv */
827 hw->h_lport.p_element.type = LLDP_TLV_AA_ELEM_TYPE_CLIENT_VIRTUAL_SWITCH;
828 hw->h_lport.p_element.mgmt_vlan = 0;
829 memcpy(&hw->h_lport.p_element.system_id.system_mac,
830 lchassis->c_id, lchassis->c_id_len);
831 hw->h_lport.p_element.system_id.conn_type =
832 LLDP_TLV_AA_ELEM_CONN_TYPE_SINGLE;
833 hw->h_lport.p_element.system_id.rsvd = 0;
834 hw->h_lport.p_element.system_id.rsvd2[0] = 0;
835 hw->h_lport.p_element.system_id.rsvd2[1] = 0;
837 ovs_list_init(&hw->h_lport.p_isid_vlan_maps);
838 ovs_list_init(&lldp->lldpd->g_hardware);
839 ovs_list_push_back(&lldp->lldpd->g_hardware, &hw->h_entries);
841 ovs_mutex_lock(&mutex);
843 /* Update port with Auto Attach mappings configured. */
844 HMAP_FOR_EACH (m, hmap_node_isid, all_mappings) {
845 struct aa_mapping_internal *p;
847 if (mapping_find_by_isid(lldp, m->isid)) {
851 p = xmemdup(m, sizeof *p);
852 hmap_insert(&lldp->mappings_by_isid, &p->hmap_node_isid,
853 hash_int(p->isid, 0));
854 hmap_insert(&lldp->mappings_by_aux,
856 hash_pointer(p->aux, 0));
858 update_mapping_on_lldp(lldp, hw, p);
861 hmap_insert(all_lldps, &lldp->hmap_node,
862 hash_string(netdev_get_name(netdev), 0));
864 ovs_mutex_unlock(&mutex);
871 lldp_create_dummy(void)
874 struct lldpd_chassis *lchassis;
875 struct lldpd_hardware *hw;
877 lldp = xzalloc(sizeof *lldp);
878 lldp->name = "dummy-lldp";
879 lldp->lldpd = xzalloc(sizeof *lldp->lldpd);
881 hmap_init(&lldp->mappings_by_isid);
882 hmap_init(&lldp->mappings_by_aux);
883 ovs_list_init(&lldp->active_mapping_queue);
885 lchassis = xzalloc(sizeof *lchassis);
886 lchassis->c_cap_available = LLDP_CAP_BRIDGE;
887 lchassis->c_cap_enabled = LLDP_CAP_BRIDGE;
888 lchassis->c_id_subtype = LLDP_CHASSISID_SUBTYPE_LLADDR;
889 lchassis->c_id_len = ETH_ADDR_LEN;
891 ovs_list_init(&lchassis->c_mgmt);
892 lchassis->c_ttl = LLDP_CHASSIS_TTL;
893 lldpd_assign_cfg_to_protocols(lldp->lldpd);
894 ovs_list_init(&lldp->lldpd->g_chassis);
895 ovs_list_push_back(&lldp->lldpd->g_chassis, &lchassis->list);
897 hw = lldpd_alloc_hardware(lldp->lldpd, "dummy-hw", 0);
899 ovs_refcount_init(&lldp->ref_cnt);
901 hw->h_flags |= IFF_RUNNING;
904 hw->h_lport.p_id_subtype = LLDP_PORTID_SUBTYPE_IFNAME;
905 hw->h_lport.p_id = "dummy-port";
907 /* p_id is not necessarily a null terminated string. */
908 hw->h_lport.p_id_len = strlen(hw->h_lport.p_id);
910 /* Auto Attach element tlv */
911 hw->h_lport.p_element.type = LLDP_TLV_AA_ELEM_TYPE_CLIENT_VIRTUAL_SWITCH;
912 hw->h_lport.p_element.mgmt_vlan = 0;
913 hw->h_lport.p_element.system_id.conn_type =
914 LLDP_TLV_AA_ELEM_CONN_TYPE_SINGLE;
915 hw->h_lport.p_element.system_id.rsvd = 0;
916 hw->h_lport.p_element.system_id.rsvd2[0] = 0;
917 hw->h_lport.p_element.system_id.rsvd2[1] = 0;
919 ovs_list_init(&hw->h_lport.p_isid_vlan_maps);
920 ovs_list_init(&lldp->lldpd->g_hardware);
921 ovs_list_push_back(&lldp->lldpd->g_hardware, &hw->h_entries);
926 /* Unreference a specific LLDP instance.
929 lldp_unref(struct lldp *lldp)
935 ovs_mutex_lock(&mutex);
936 if (ovs_refcount_unref_relaxed(&lldp->ref_cnt) != 1) {
937 ovs_mutex_unlock(&mutex);
941 hmap_remove(all_lldps, &lldp->hmap_node);
942 ovs_mutex_unlock(&mutex);
944 lldpd_cleanup(lldp->lldpd);
950 /* Reference a specific LLDP instance.
953 lldp_ref(const struct lldp *lldp_)
955 struct lldp *lldp = CONST_CAST(struct lldp *, lldp_);
957 ovs_refcount_ref(&lldp->ref_cnt);
963 lldp_destroy_dummy(struct lldp *lldp)
965 struct lldpd_hardware *hw, *hw_next;
966 struct lldpd_chassis *chassis, *chassis_next;
975 LIST_FOR_EACH_SAFE (hw, hw_next, h_entries, &cfg->g_hardware) {
976 ovs_list_remove(&hw->h_entries);
977 free(hw->h_lport.p_lastframe);
981 LIST_FOR_EACH_SAFE (chassis, chassis_next, list, &cfg->g_chassis) {
982 ovs_list_remove(&chassis->list);