![[BACK]](/icons/back.gif){kind=icon}
Return to bridgestp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net|
Return to bridgestp.c CVS log | Up to [local] / sys / net |
1.1 nbrk 1: /* $OpenBSD: bridgestp.c,v 1.26 2007/02/15 12:43:26 reyk Exp $ */
2:
3: /*
4: * Copyright (c) 2000 Jason L. Wright (jason@thought.net)
5: * Copyright (c) 2006 Andrew Thompson (thompsa@FreeBSD.org)
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
21: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
25: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27: * POSSIBILITY OF SUCH DAMAGE.
28: */
29:
30: /*
31: * Implementation of the spanning tree protocol as defined in
32: * ISO/IEC 802.1D-2004, June 9, 2004.
33: */
34:
35: #if 0
36: __FBSDID("$FreeBSD: /repoman/r/ncvs/src/sys/net/bridgestp.c,v 1.25 2006/11/03 03:34:04 thompsa Exp $");
37: #endif
38:
39: #include "bridge.h"
40:
41: #if NBRIDGE > 0
42:
43: #include <sys/param.h>
44: #include <sys/systm.h>
45: #include <sys/mbuf.h>
46: #include <sys/socket.h>
47: #include <sys/ioctl.h>
48: #include <sys/device.h>
49: #include <sys/kernel.h>
50: #include <sys/timeout.h>
51:
52: #include <net/if.h>
53: #include <net/if_types.h>
54: #include <net/if_dl.h>
55: #include <net/if_llc.h>
56: #include <net/if_media.h>
57: #include <net/route.h>
58: #include <net/netisr.h>
59:
60: #ifdef INET
61: #include <netinet/in.h>
62: #include <netinet/in_systm.h>
63: #include <netinet/in_var.h>
64: #include <netinet/ip.h>
65: #include <netinet/if_ether.h>
66: #endif
67:
68: #if NBPFILTER > 0
69: #include <net/bpf.h>
70: #endif
71:
72: #include <net/if_bridge.h>
73:
74: /* STP port states */
75: #define BSTP_IFSTATE_DISABLED 0
76: #define BSTP_IFSTATE_LISTENING 1
77: #define BSTP_IFSTATE_LEARNING 2
78: #define BSTP_IFSTATE_FORWARDING 3
79: #define BSTP_IFSTATE_BLOCKING 4
80: #define BSTP_IFSTATE_DISCARDING 5
81:
82: #define BSTP_TCSTATE_ACTIVE 1
83: #define BSTP_TCSTATE_DETECTED 2
84: #define BSTP_TCSTATE_INACTIVE 3
85: #define BSTP_TCSTATE_LEARNING 4
86: #define BSTP_TCSTATE_PROPAG 5
87: #define BSTP_TCSTATE_ACK 6
88: #define BSTP_TCSTATE_TC 7
89: #define BSTP_TCSTATE_TCN 8
90:
91: #define BSTP_ROLE_DISABLED 0
92: #define BSTP_ROLE_ROOT 1
93: #define BSTP_ROLE_DESIGNATED 2
94: #define BSTP_ROLE_ALTERNATE 3
95: #define BSTP_ROLE_BACKUP 4
96:
97: /* STP port flags */
98: #define BSTP_PORT_CANMIGRATE 0x0001
99: #define BSTP_PORT_NEWINFO 0x0002
100: #define BSTP_PORT_DISPUTED 0x0004
101: #define BSTP_PORT_ADMCOST 0x0008
102: #define BSTP_PORT_AUTOEDGE 0x0010
103:
104: /* BPDU priority */
105: #define BSTP_PDU_SUPERIOR 1
106: #define BSTP_PDU_REPEATED 2
107: #define BSTP_PDU_INFERIOR 3
108: #define BSTP_PDU_INFERIORALT 4
109: #define BSTP_PDU_OTHER 5
110:
111: /* BPDU flags */
112: #define BSTP_PDU_PRMASK 0x0c /* Port Role */
113: #define BSTP_PDU_PRSHIFT 2 /* Port Role offset */
114: #define BSTP_PDU_F_UNKN 0x00 /* Unknown port (00) */
115: #define BSTP_PDU_F_ALT 0x01 /* Alt/Backup port (01) */
116: #define BSTP_PDU_F_ROOT 0x02 /* Root port (10) */
117: #define BSTP_PDU_F_DESG 0x03 /* Designated port (11) */
118:
119: #define BSTP_PDU_STPMASK 0x81 /* strip unused STP flags */
120: #define BSTP_PDU_RSTPMASK 0x7f /* strip unused RSTP flags */
121: #define BSTP_PDU_F_TC 0x01 /* Topology change */
122: #define BSTP_PDU_F_P 0x02 /* Proposal flag */
123: #define BSTP_PDU_F_L 0x10 /* Learning flag */
124: #define BSTP_PDU_F_F 0x20 /* Forwarding flag */
125: #define BSTP_PDU_F_A 0x40 /* Agreement flag */
126: #define BSTP_PDU_F_TCA 0x80 /* Topology change ack */
127:
128: /*
129: * Spanning tree defaults.
130: */
131: #define BSTP_DEFAULT_MAX_AGE (20 * 256)
132: #define BSTP_DEFAULT_HELLO_TIME (2 * 256)
133: #define BSTP_DEFAULT_FORWARD_DELAY (15 * 256)
134: #define BSTP_DEFAULT_HOLD_TIME (1 * 256)
135: #define BSTP_DEFAULT_MIGRATE_DELAY (3 * 256)
136: #define BSTP_DEFAULT_HOLD_COUNT 6
137: #define BSTP_DEFAULT_BRIDGE_PRIORITY 0x8000
138: #define BSTP_DEFAULT_PORT_PRIORITY 0x80
139: #define BSTP_DEFAULT_PATH_COST 55
140: #define BSTP_MIN_HELLO_TIME (1 * 256)
141: #define BSTP_MIN_MAX_AGE (6 * 256)
142: #define BSTP_MIN_FORWARD_DELAY (4 * 256)
143: #define BSTP_MIN_HOLD_COUNT 1
144: #define BSTP_MAX_HELLO_TIME (2 * 256)
145: #define BSTP_MAX_MAX_AGE (40 * 256)
146: #define BSTP_MAX_FORWARD_DELAY (30 * 256)
147: #define BSTP_MAX_HOLD_COUNT 10
148: #define BSTP_MAX_PRIORITY 61440
149: #define BSTP_MAX_PORT_PRIORITY 240
150: #define BSTP_MAX_PATH_COST 200000000
151:
152: /* BPDU message types */
153: #define BSTP_MSGTYPE_CFG 0x00 /* Configuration */
154: #define BSTP_MSGTYPE_RSTP 0x02 /* Rapid STP */
155: #define BSTP_MSGTYPE_TCN 0x80 /* Topology chg notification */
156:
157: #define BSTP_INFO_RECIEVED 1
158: #define BSTP_INFO_MINE 2
159: #define BSTP_INFO_AGED 3
160: #define BSTP_INFO_DISABLED 4
161:
162: #define BSTP_MESSAGE_AGE_INCR (1 * 256) /* in 256ths of a second */
163: #define BSTP_TICK_VAL (1 * 256) /* in 256ths of a second */
164: #define BSTP_LINK_TIMER (BSTP_TICK_VAL * 15)
165:
166: #ifdef BRIDGESTP_DEBUG
167: #define DPRINTF(fmt, arg...) printf("bstp: " fmt, ##arg)
168: #else
169: #define DPRINTF(fmt, arg...)
170: #endif
171:
172: #define PV2ADDR(pv, eaddr) do { \
173: eaddr[0] = pv >> 40; \
174: eaddr[1] = pv >> 32; \
175: eaddr[2] = pv >> 24; \
176: eaddr[3] = pv >> 16; \
177: eaddr[4] = pv >> 8; \
178: eaddr[5] = pv >> 0; \
179: } while (0)
180:
181: #define INFO_BETTER 1
182: #define INFO_SAME 0
183: #define INFO_WORSE -1
184:
185: /*
186: * Because BPDU's do not make nicely aligned structures, two different
187: * declarations are used: bstp_?bpdu (wire representation, packed) and
188: * bstp_*_unit (internal, nicely aligned version).
189: */
190:
191: /* configuration bridge protocol data unit */
192: struct bstp_cbpdu {
193: u_int8_t cbu_dsap; /* LLC: destination sap */
194: u_int8_t cbu_ssap; /* LLC: source sap */
195: u_int8_t cbu_ctl; /* LLC: control */
196: u_int16_t cbu_protoid; /* protocol id */
197: u_int8_t cbu_protover; /* protocol version */
198: u_int8_t cbu_bpdutype; /* message type */
199: u_int8_t cbu_flags; /* flags (below) */
200:
201: /* root id */
202: u_int16_t cbu_rootpri; /* root priority */
203: u_int8_t cbu_rootaddr[6]; /* root address */
204:
205: u_int32_t cbu_rootpathcost; /* root path cost */
206:
207: /* bridge id */
208: u_int16_t cbu_bridgepri; /* bridge priority */
209: u_int8_t cbu_bridgeaddr[6]; /* bridge address */
210:
211: u_int16_t cbu_portid; /* port id */
212: u_int16_t cbu_messageage; /* current message age */
213: u_int16_t cbu_maxage; /* maximum age */
214: u_int16_t cbu_hellotime; /* hello time */
215: u_int16_t cbu_forwarddelay; /* forwarding delay */
216: u_int8_t cbu_versionlen; /* version 1 length */
217: } __packed;
218:
219: #define BSTP_BPDU_STP_LEN (3 + 35) /* LLC + STP pdu */
220: #define BSTP_BPDU_RSTP_LEN (3 + 36) /* LLC + RSTP pdu */
221:
222: /* topology change notification bridge protocol data unit */
223: struct bstp_tbpdu {
224: u_int8_t tbu_dsap; /* LLC: destination sap */
225: u_int8_t tbu_ssap; /* LLC: source sap */
226: u_int8_t tbu_ctl; /* LLC: control */
227: u_int16_t tbu_protoid; /* protocol id */
228: u_int8_t tbu_protover; /* protocol version */
229: u_int8_t tbu_bpdutype; /* message type */
230: } __packed;
231:
232: const u_int8_t bstp_etheraddr[] = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
233:
234: LIST_HEAD(, bstp_state) bstp_list;
235:
236: void bstp_transmit(struct bstp_state *, struct bstp_port *);
237: void bstp_transmit_bpdu(struct bstp_state *, struct bstp_port *);
238: void bstp_transmit_tcn(struct bstp_state *, struct bstp_port *);
239: void bstp_decode_bpdu(struct bstp_port *, struct bstp_cbpdu *,
240: struct bstp_config_unit *);
241: void bstp_send_bpdu(struct bstp_state *, struct bstp_port *,
242: struct bstp_cbpdu *);
243: int bstp_pdu_flags(struct bstp_port *);
244: void bstp_received_stp(struct bstp_state *, struct bstp_port *,
245: struct mbuf **, struct bstp_tbpdu *);
246: void bstp_received_rstp(struct bstp_state *, struct bstp_port *,
247: struct mbuf **, struct bstp_tbpdu *);
248: void bstp_received_tcn(struct bstp_state *, struct bstp_port *,
249: struct bstp_tcn_unit *);
250: void bstp_received_bpdu(struct bstp_state *, struct bstp_port *,
251: struct bstp_config_unit *);
252: int bstp_pdu_rcvtype(struct bstp_port *, struct bstp_config_unit *);
253: int bstp_pdu_bettersame(struct bstp_port *, int);
254: int bstp_info_cmp(struct bstp_pri_vector *,
255: struct bstp_pri_vector *);
256: int bstp_info_superior(struct bstp_pri_vector *,
257: struct bstp_pri_vector *);
258: void bstp_assign_roles(struct bstp_state *);
259: void bstp_update_roles(struct bstp_state *, struct bstp_port *);
260: void bstp_update_state(struct bstp_state *, struct bstp_port *);
261: void bstp_update_tc(struct bstp_port *);
262: void bstp_update_info(struct bstp_port *);
263: void bstp_set_other_tcprop(struct bstp_port *);
264: void bstp_set_all_reroot(struct bstp_state *);
265: void bstp_set_all_sync(struct bstp_state *);
266: void bstp_set_port_state(struct bstp_port *, int);
267: void bstp_set_port_role(struct bstp_port *, int);
268: void bstp_set_port_proto(struct bstp_port *, int);
269: void bstp_set_port_tc(struct bstp_port *, int);
270: void bstp_set_timer_tc(struct bstp_port *);
271: void bstp_set_timer_msgage(struct bstp_port *);
272: int bstp_rerooted(struct bstp_state *, struct bstp_port *);
273: u_int32_t bstp_calc_path_cost(struct bstp_port *);
274: void bstp_notify_rtage(void *, int);
275: void bstp_ifupdstatus(struct bstp_state *, struct bstp_port *);
276: void bstp_enable_port(struct bstp_state *, struct bstp_port *);
277: void bstp_disable_port(struct bstp_state *, struct bstp_port *);
278: void bstp_tick(void *);
279: void bstp_timer_start(struct bstp_timer *, u_int16_t);
280: void bstp_timer_stop(struct bstp_timer *);
281: void bstp_timer_latch(struct bstp_timer *);
282: int bstp_timer_expired(struct bstp_timer *);
283: void bstp_hello_timer_expiry(struct bstp_state *,
284: struct bstp_port *);
285: void bstp_message_age_expiry(struct bstp_state *,
286: struct bstp_port *);
287: void bstp_migrate_delay_expiry(struct bstp_state *,
288: struct bstp_port *);
289: void bstp_edge_delay_expiry(struct bstp_state *,
290: struct bstp_port *);
291: int bstp_addr_cmp(const u_int8_t *, const u_int8_t *);
292: int bstp_same_bridgeid(u_int64_t, u_int64_t);
293:
294: void
295: bstp_attach(int n)
296: {
297: LIST_INIT(&bstp_list);
298: }
299:
300: void
301: bstp_transmit(struct bstp_state *bs, struct bstp_port *bp)
302: {
303: if ((bs->bs_ifflags & IFF_RUNNING) == 0 || bp == NULL)
304: return;
305:
306: /*
307: * a PDU can only be sent if we have tx quota left and the
308: * hello timer is running.
309: */
310: if (bp->bp_hello_timer.active == 0) {
311: /* Test if it needs to be reset */
312: bstp_hello_timer_expiry(bs, bp);
313: return;
314: }
315: if (bp->bp_txcount > bs->bs_txholdcount)
316: /* Ran out of karma */
317: return;
318:
319: if (bp->bp_protover == BSTP_PROTO_RSTP) {
320: bstp_transmit_bpdu(bs, bp);
321: bp->bp_tc_ack = 0;
322: } else { /* STP */
323: switch (bp->bp_role) {
324: case BSTP_ROLE_DESIGNATED:
325: bstp_transmit_bpdu(bs, bp);
326: bp->bp_tc_ack = 0;
327: break;
328:
329: case BSTP_ROLE_ROOT:
330: bstp_transmit_tcn(bs, bp);
331: break;
332: }
333: }
334: bstp_timer_start(&bp->bp_hello_timer, bp->bp_desg_htime);
335: bp->bp_flags &= ~BSTP_PORT_NEWINFO;
336: }
337:
338: void
339: bstp_transmit_bpdu(struct bstp_state *bs, struct bstp_port *bp)
340: {
341: struct bstp_cbpdu bpdu;
342:
343: bpdu.cbu_rootpri = htons(bp->bp_desg_pv.pv_root_id >> 48);
344: PV2ADDR(bp->bp_desg_pv.pv_root_id, bpdu.cbu_rootaddr);
345:
346: bpdu.cbu_rootpathcost = htonl(bp->bp_desg_pv.pv_cost);
347:
348: bpdu.cbu_bridgepri = htons(bp->bp_desg_pv.pv_dbridge_id >> 48);
349: PV2ADDR(bp->bp_desg_pv.pv_dbridge_id, bpdu.cbu_bridgeaddr);
350:
351: bpdu.cbu_portid = htons(bp->bp_port_id);
352: bpdu.cbu_messageage = htons(bp->bp_desg_msg_age);
353: bpdu.cbu_maxage = htons(bp->bp_desg_max_age);
354: bpdu.cbu_hellotime = htons(bp->bp_desg_htime);
355: bpdu.cbu_forwarddelay = htons(bp->bp_desg_fdelay);
356:
357: bpdu.cbu_flags = bstp_pdu_flags(bp);
358:
359: switch (bp->bp_protover) {
360: case BSTP_PROTO_STP:
361: bpdu.cbu_bpdutype = BSTP_MSGTYPE_CFG;
362: break;
363: case BSTP_PROTO_RSTP:
364: bpdu.cbu_bpdutype = BSTP_MSGTYPE_RSTP;
365: break;
366: }
367:
368: bstp_send_bpdu(bs, bp, &bpdu);
369: }
370:
371: void
372: bstp_transmit_tcn(struct bstp_state *bs, struct bstp_port *bp)
373: {
374: struct bstp_tbpdu bpdu;
375: struct ifnet *ifp = bp->bp_ifp;
376: struct ether_header *eh;
377: struct mbuf *m;
378: int s,error;
379:
380: if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0)
381: return;
382:
383: MGETHDR(m, M_DONTWAIT, MT_DATA);
384: if (m == NULL)
385: return;
386: m->m_pkthdr.rcvif = ifp;
387: m->m_pkthdr.len = sizeof(*eh) + sizeof(bpdu);
388: m->m_len = m->m_pkthdr.len;
389:
390: eh = mtod(m, struct ether_header *);
391: bcopy(LLADDR(ifp->if_sadl), eh->ether_shost, ETHER_ADDR_LEN);
392: bcopy(bstp_etheraddr, eh->ether_dhost, ETHER_ADDR_LEN);
393: eh->ether_type = htons(sizeof(bpdu));
394:
395: bpdu.tbu_ssap = bpdu.tbu_dsap = LLC_8021D_LSAP;
396: bpdu.tbu_ctl = LLC_UI;
397: bpdu.tbu_protoid = 0;
398: bpdu.tbu_protover = 0;
399: bpdu.tbu_bpdutype = BSTP_MSGTYPE_TCN;
400: bcopy(&bpdu, mtod(m, caddr_t) + sizeof(*eh), sizeof(bpdu));
401:
402: s = splnet();
403: bp->bp_txcount++;
404: IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
405: if (error == 0 && (ifp->if_flags & IFF_OACTIVE) == 0)
406: (*ifp->if_start)(ifp);
407: splx(s);
408: }
409:
410: void
411: bstp_decode_bpdu(struct bstp_port *bp, struct bstp_cbpdu *cpdu,
412: struct bstp_config_unit *cu)
413: {
414: int flags;
415:
416: cu->cu_pv.pv_root_id =
417: (((u_int64_t)ntohs(cpdu->cbu_rootpri)) << 48) |
418: (((u_int64_t)cpdu->cbu_rootaddr[0]) << 40) |
419: (((u_int64_t)cpdu->cbu_rootaddr[1]) << 32) |
420: (((u_int64_t)cpdu->cbu_rootaddr[2]) << 24) |
421: (((u_int64_t)cpdu->cbu_rootaddr[3]) << 16) |
422: (((u_int64_t)cpdu->cbu_rootaddr[4]) << 8) |
423: (((u_int64_t)cpdu->cbu_rootaddr[5]) << 0);
424:
425: cu->cu_pv.pv_dbridge_id =
426: (((u_int64_t)ntohs(cpdu->cbu_bridgepri)) << 48) |
427: (((u_int64_t)cpdu->cbu_bridgeaddr[0]) << 40) |
428: (((u_int64_t)cpdu->cbu_bridgeaddr[1]) << 32) |
429: (((u_int64_t)cpdu->cbu_bridgeaddr[2]) << 24) |
430: (((u_int64_t)cpdu->cbu_bridgeaddr[3]) << 16) |
431: (((u_int64_t)cpdu->cbu_bridgeaddr[4]) << 8) |
432: (((u_int64_t)cpdu->cbu_bridgeaddr[5]) << 0);
433:
434: cu->cu_pv.pv_cost = ntohl(cpdu->cbu_rootpathcost);
435: cu->cu_message_age = ntohs(cpdu->cbu_messageage);
436: cu->cu_max_age = ntohs(cpdu->cbu_maxage);
437: cu->cu_hello_time = ntohs(cpdu->cbu_hellotime);
438: cu->cu_forward_delay = ntohs(cpdu->cbu_forwarddelay);
439: cu->cu_pv.pv_dport_id = ntohs(cpdu->cbu_portid);
440: cu->cu_pv.pv_port_id = bp->bp_port_id;
441: cu->cu_message_type = cpdu->cbu_bpdutype;
442:
443: /* Strip off unused flags in STP mode */
444: flags = cpdu->cbu_flags;
445: switch (cpdu->cbu_protover) {
446: case BSTP_PROTO_STP:
447: flags &= BSTP_PDU_STPMASK;
448: /* A STP BPDU explicitly conveys a Designated Port */
449: cu->cu_role = BSTP_ROLE_DESIGNATED;
450: break;
451: case BSTP_PROTO_RSTP:
452: flags &= BSTP_PDU_RSTPMASK;
453: break;
454: }
455:
456: cu->cu_topology_change_ack =
457: (flags & BSTP_PDU_F_TCA) ? 1 : 0;
458: cu->cu_proposal =
459: (flags & BSTP_PDU_F_P) ? 1 : 0;
460: cu->cu_agree =
461: (flags & BSTP_PDU_F_A) ? 1 : 0;
462: cu->cu_learning =
463: (flags & BSTP_PDU_F_L) ? 1 : 0;
464: cu->cu_forwarding =
465: (flags & BSTP_PDU_F_F) ? 1 : 0;
466: cu->cu_topology_change =
467: (flags & BSTP_PDU_F_TC) ? 1 : 0;
468:
469: switch ((flags & BSTP_PDU_PRMASK) >> BSTP_PDU_PRSHIFT) {
470: case BSTP_PDU_F_ROOT:
471: cu->cu_role = BSTP_ROLE_ROOT;
472: break;
473: case BSTP_PDU_F_ALT:
474: cu->cu_role = BSTP_ROLE_ALTERNATE;
475: break;
476: case BSTP_PDU_F_DESG:
477: cu->cu_role = BSTP_ROLE_DESIGNATED;
478: break;
479: }
480: }
481:
482: void
483: bstp_send_bpdu(struct bstp_state *bs, struct bstp_port *bp,
484: struct bstp_cbpdu *bpdu)
485: {
486: struct ifnet *ifp = bp->bp_ifp;
487: struct mbuf *m;
488: struct ether_header *eh;
489: int s, error;
490:
491: s = splnet();
492: if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0)
493: goto done;
494:
495: #ifdef ALTQ
496: if (!ALTQ_IS_ENABLED(&ifp->if_snd))
497: #endif
498: if (IF_QFULL(&ifp->if_snd))
499: goto done;
500:
501: MGETHDR(m, M_DONTWAIT, MT_DATA);
502: if (m == NULL)
503: goto done;
504:
505: eh = mtod(m, struct ether_header *);
506:
507: bpdu->cbu_ssap = bpdu->cbu_dsap = LLC_8021D_LSAP;
508: bpdu->cbu_ctl = LLC_UI;
509: bpdu->cbu_protoid = htons(BSTP_PROTO_ID);
510:
511: memcpy(eh->ether_shost, LLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
512: memcpy(eh->ether_dhost, bstp_etheraddr, ETHER_ADDR_LEN);
513:
514: switch (bpdu->cbu_bpdutype) {
515: case BSTP_MSGTYPE_CFG:
516: bpdu->cbu_protover = BSTP_PROTO_STP;
517: m->m_pkthdr.len = sizeof(*eh) + BSTP_BPDU_STP_LEN;
518: eh->ether_type = htons(BSTP_BPDU_STP_LEN);
519: memcpy(mtod(m, caddr_t) + sizeof(*eh), bpdu,
520: BSTP_BPDU_STP_LEN);
521: break;
522: case BSTP_MSGTYPE_RSTP:
523: bpdu->cbu_protover = BSTP_PROTO_RSTP;
524: bpdu->cbu_versionlen = htons(0);
525: m->m_pkthdr.len = sizeof(*eh) + BSTP_BPDU_RSTP_LEN;
526: eh->ether_type = htons(BSTP_BPDU_RSTP_LEN);
527: memcpy(mtod(m, caddr_t) + sizeof(*eh), bpdu,
528: BSTP_BPDU_RSTP_LEN);
529: break;
530: default:
531: panic("not implemented");
532: }
533: m->m_pkthdr.rcvif = ifp;
534: m->m_len = m->m_pkthdr.len;
535:
536: bp->bp_txcount++;
537: IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
538: if (error == 0 && (ifp->if_flags & IFF_OACTIVE) == 0)
539: (*ifp->if_start)(ifp);
540: done:
541: splx(s);
542: }
543:
544: int
545: bstp_pdu_flags(struct bstp_port *bp)
546: {
547: int flags = 0;
548:
549: if (bp->bp_proposing && bp->bp_state != BSTP_IFSTATE_FORWARDING)
550: flags |= BSTP_PDU_F_P;
551:
552: if (bp->bp_agree)
553: flags |= BSTP_PDU_F_A;
554:
555: if (bp->bp_tc_timer.active)
556: flags |= BSTP_PDU_F_TC;
557:
558: if (bp->bp_tc_ack)
559: flags |= BSTP_PDU_F_TCA;
560:
561: switch (bp->bp_state) {
562: case BSTP_IFSTATE_LEARNING:
563: flags |= BSTP_PDU_F_L;
564: break;
565: case BSTP_IFSTATE_FORWARDING:
566: flags |= (BSTP_PDU_F_L | BSTP_PDU_F_F);
567: break;
568: }
569:
570: switch (bp->bp_role) {
571: case BSTP_ROLE_ROOT:
572: flags |= (BSTP_PDU_F_ROOT << BSTP_PDU_PRSHIFT);
573: break;
574: case BSTP_ROLE_ALTERNATE:
575: case BSTP_ROLE_BACKUP:
576: flags |= (BSTP_PDU_F_ALT << BSTP_PDU_PRSHIFT);
577: break;
578: case BSTP_ROLE_DESIGNATED:
579: flags |= (BSTP_PDU_F_DESG << BSTP_PDU_PRSHIFT);
580: break;
581: }
582:
583: /* Strip off unused flags in either mode */
584: switch (bp->bp_protover) {
585: case BSTP_PROTO_STP:
586: flags &= BSTP_PDU_STPMASK;
587: break;
588: case BSTP_PROTO_RSTP:
589: flags &= BSTP_PDU_RSTPMASK;
590: break;
591: }
592: return (flags);
593: }
594:
595: struct mbuf *
596: bstp_input(struct bstp_state *bs, struct bstp_port *bp,
597: struct ether_header *eh, struct mbuf *m)
598: {
599: struct bstp_tbpdu tpdu;
600: u_int16_t len;
601:
602: if (bs == NULL || bp == NULL || bp->bp_active == 0)
603: goto out;
604:
605: len = ntohs(eh->ether_type);
606: if (len < sizeof(tpdu))
607: goto out;
608: if (m->m_pkthdr.len > len)
609: m_adj(m, len - m->m_pkthdr.len);
610: if ((m = m_pullup(m, sizeof(tpdu))) == NULL)
611: goto out;
612: bcopy(mtod(m, struct tpdu *), &tpdu, sizeof(tpdu));
613:
614: if (tpdu.tbu_dsap != LLC_8021D_LSAP ||
615: tpdu.tbu_ssap != LLC_8021D_LSAP ||
616: tpdu.tbu_ctl != LLC_UI)
617: goto out;
618: if (tpdu.tbu_protoid != BSTP_PROTO_ID)
619: goto out;
620:
621: /*
622: * We can treat later versions of the PDU as the same as the maximum
623: * version we implement. All additional parameters/flags are ignored.
624: */
625: if (tpdu.tbu_protover > BSTP_PROTO_MAX)
626: tpdu.tbu_protover = BSTP_PROTO_MAX;
627:
628: if (tpdu.tbu_protover != bp->bp_protover) {
629: /*
630: * Wait for the migration delay timer to expire before changing
631: * protocol version to avoid flip-flops.
632: */
633: if (bp->bp_flags & BSTP_PORT_CANMIGRATE)
634: bstp_set_port_proto(bp, tpdu.tbu_protover);
635: else
636: goto out;
637: }
638:
639: /* Clear operedge upon receiving a PDU on the port */
640: bp->bp_operedge = 0;
641: bstp_timer_start(&bp->bp_edge_delay_timer,
642: BSTP_DEFAULT_MIGRATE_DELAY);
643:
644: switch (tpdu.tbu_protover) {
645: case BSTP_PROTO_STP:
646: bstp_received_stp(bs, bp, &m, &tpdu);
647: break;
648: case BSTP_PROTO_RSTP:
649: bstp_received_rstp(bs, bp, &m, &tpdu);
650: break;
651: }
652: out:
653: if (m)
654: m_freem(m);
655: return (NULL);
656: }
657:
658: void
659: bstp_received_stp(struct bstp_state *bs, struct bstp_port *bp,
660: struct mbuf **mp, struct bstp_tbpdu *tpdu)
661: {
662: struct bstp_cbpdu cpdu;
663: struct bstp_config_unit *cu = &bp->bp_msg_cu;
664: struct bstp_tcn_unit tu;
665:
666: switch (tpdu->tbu_bpdutype) {
667: case BSTP_MSGTYPE_TCN:
668: tu.tu_message_type = tpdu->tbu_bpdutype;
669: bstp_received_tcn(bs, bp, &tu);
670: break;
671: case BSTP_MSGTYPE_CFG:
672: if ((*mp)->m_len < BSTP_BPDU_STP_LEN &&
673: (*mp = m_pullup(*mp, BSTP_BPDU_STP_LEN)) == NULL)
674: return;
675: memcpy(&cpdu, mtod(*mp, caddr_t), BSTP_BPDU_STP_LEN);
676:
677: bstp_decode_bpdu(bp, &cpdu, cu);
678: bstp_received_bpdu(bs, bp, cu);
679: break;
680: }
681: }
682:
683: void
684: bstp_received_rstp(struct bstp_state *bs, struct bstp_port *bp,
685: struct mbuf **mp, struct bstp_tbpdu *tpdu)
686: {
687: struct bstp_cbpdu cpdu;
688: struct bstp_config_unit *cu = &bp->bp_msg_cu;
689:
690: if (tpdu->tbu_bpdutype != BSTP_MSGTYPE_RSTP)
691: return;
692:
693: if ((*mp)->m_len < BSTP_BPDU_RSTP_LEN &&
694: (*mp = m_pullup(*mp, BSTP_BPDU_RSTP_LEN)) == NULL)
695: return;
696: memcpy(&cpdu, mtod(*mp, caddr_t), BSTP_BPDU_RSTP_LEN);
697:
698: bstp_decode_bpdu(bp, &cpdu, cu);
699: bstp_received_bpdu(bs, bp, cu);
700: }
701:
702: void
703: bstp_received_tcn(struct bstp_state *bs, struct bstp_port *bp,
704: struct bstp_tcn_unit *tcn)
705: {
706: bp->bp_rcvdtcn = 1;
707: bstp_update_tc(bp);
708: }
709:
710: void
711: bstp_received_bpdu(struct bstp_state *bs, struct bstp_port *bp,
712: struct bstp_config_unit *cu)
713: {
714: int type;
715:
716: /* We need to have transitioned to INFO_MINE before proceeding */
717: switch (bp->bp_infois) {
718: case BSTP_INFO_DISABLED:
719: case BSTP_INFO_AGED:
720: return;
721: }
722:
723: type = bstp_pdu_rcvtype(bp, cu);
724:
725: switch (type) {
726: case BSTP_PDU_SUPERIOR:
727: bs->bs_allsynced = 0;
728: bp->bp_agreed = 0;
729: bp->bp_proposing = 0;
730:
731: if (cu->cu_proposal && cu->cu_forwarding == 0)
732: bp->bp_proposed = 1;
733: if (cu->cu_topology_change)
734: bp->bp_rcvdtc = 1;
735: if (cu->cu_topology_change_ack)
736: bp->bp_rcvdtca = 1;
737:
738: if (bp->bp_agree &&
739: !bstp_pdu_bettersame(bp, BSTP_INFO_RECIEVED))
740: bp->bp_agree = 0;
741:
742: /* copy the received priority and timers to the port */
743: bp->bp_port_pv = cu->cu_pv;
744: bp->bp_port_msg_age = cu->cu_message_age;
745: bp->bp_port_max_age = cu->cu_max_age;
746: bp->bp_port_fdelay = cu->cu_forward_delay;
747: bp->bp_port_htime =
748: (cu->cu_hello_time > BSTP_MIN_HELLO_TIME ?
749: cu->cu_hello_time : BSTP_MIN_HELLO_TIME);
750:
751: /* set expiry for the new info */
752: bstp_set_timer_msgage(bp);
753:
754: bp->bp_infois = BSTP_INFO_RECIEVED;
755: bstp_assign_roles(bs);
756: break;
757:
758: case BSTP_PDU_REPEATED:
759: if (cu->cu_proposal && cu->cu_forwarding == 0)
760: bp->bp_proposed = 1;
761: if (cu->cu_topology_change)
762: bp->bp_rcvdtc = 1;
763: if (cu->cu_topology_change_ack)
764: bp->bp_rcvdtca = 1;
765:
766: /* rearm the age timer */
767: bstp_set_timer_msgage(bp);
768: break;
769:
770: case BSTP_PDU_INFERIOR:
771: if (cu->cu_learning) {
772: bp->bp_agreed = 1;
773: bp->bp_proposing = 0;
774: }
775: break;
776:
777: case BSTP_PDU_INFERIORALT:
778: /*
779: * only point to point links are allowed fast
780: * transitions to forwarding.
781: */
782: if (cu->cu_agree && bp->bp_ptp_link) {
783: bp->bp_agreed = 1;
784: bp->bp_proposing = 0;
785: } else
786: bp->bp_agreed = 0;
787:
788: if (cu->cu_topology_change)
789: bp->bp_rcvdtc = 1;
790: if (cu->cu_topology_change_ack)
791: bp->bp_rcvdtca = 1;
792: break;
793:
794: case BSTP_PDU_OTHER:
795: return; /* do nothing */
796: }
797:
798: /* update the state machines with the new data */
799: bstp_update_state(bs, bp);
800: }
801:
802: int
803: bstp_pdu_rcvtype(struct bstp_port *bp, struct bstp_config_unit *cu)
804: {
805: int type;
806:
807: /* default return type */
808: type = BSTP_PDU_OTHER;
809:
810: switch (cu->cu_role) {
811: case BSTP_ROLE_DESIGNATED:
812: if (bstp_info_superior(&bp->bp_port_pv, &cu->cu_pv))
813: /* bpdu priority is superior */
814: type = BSTP_PDU_SUPERIOR;
815: else if (bstp_info_cmp(&bp->bp_port_pv, &cu->cu_pv) ==
816: INFO_SAME) {
817: if (bp->bp_port_msg_age != cu->cu_message_age ||
818: bp->bp_port_max_age != cu->cu_max_age ||
819: bp->bp_port_fdelay != cu->cu_forward_delay ||
820: bp->bp_port_htime != cu->cu_hello_time)
821: /* bpdu priority is equal and timers differ */
822: type = BSTP_PDU_SUPERIOR;
823: else
824: /* bpdu is equal */
825: type = BSTP_PDU_REPEATED;
826: } else
827: /* bpdu priority is worse */
828: type = BSTP_PDU_INFERIOR;
829:
830: break;
831:
832: case BSTP_ROLE_ROOT:
833: case BSTP_ROLE_ALTERNATE:
834: case BSTP_ROLE_BACKUP:
835: if (bstp_info_cmp(&bp->bp_port_pv, &cu->cu_pv) <= INFO_SAME)
836: /*
837: * not a designated port and priority is the same or
838: * worse
839: */
840: type = BSTP_PDU_INFERIORALT;
841: break;
842: }
843:
844: return (type);
845: }
846:
847: int
848: bstp_pdu_bettersame(struct bstp_port *bp, int newinfo)
849: {
850: if (newinfo == BSTP_INFO_RECIEVED &&
851: bp->bp_infois == BSTP_INFO_RECIEVED &&
852: bstp_info_cmp(&bp->bp_port_pv, &bp->bp_msg_cu.cu_pv) >= INFO_SAME)
853: return (1);
854:
855: if (newinfo == BSTP_INFO_MINE &&
856: bp->bp_infois == BSTP_INFO_MINE &&
857: bstp_info_cmp(&bp->bp_port_pv, &bp->bp_desg_pv) >= INFO_SAME)
858: return (1);
859:
860: return (0);
861: }
862:
863: int
864: bstp_info_cmp(struct bstp_pri_vector *pv,
865: struct bstp_pri_vector *cpv)
866: {
867: if (cpv->pv_root_id < pv->pv_root_id)
868: return (INFO_BETTER);
869: if (cpv->pv_root_id > pv->pv_root_id)
870: return (INFO_WORSE);
871:
872: if (cpv->pv_cost < pv->pv_cost)
873: return (INFO_BETTER);
874: if (cpv->pv_cost > pv->pv_cost)
875: return (INFO_WORSE);
876:
877: if (cpv->pv_dbridge_id < pv->pv_dbridge_id)
878: return (INFO_BETTER);
879: if (cpv->pv_dbridge_id > pv->pv_dbridge_id)
880: return (INFO_WORSE);
881:
882: if (cpv->pv_dport_id < pv->pv_dport_id)
883: return (INFO_BETTER);
884: if (cpv->pv_dport_id > pv->pv_dport_id)
885: return (INFO_WORSE);
886:
887: return (INFO_SAME);
888: }
889:
890: /*
891: * This message priority vector is superior to the port priority vector and
892: * will replace it if, and only if, the message priority vector is better than
893: * the port priority vector, or the message has been transmitted from the same
894: * designated bridge and designated port as the port priority vector.
895: */
896: int
897: bstp_info_superior(struct bstp_pri_vector *pv,
898: struct bstp_pri_vector *cpv)
899: {
900: if (bstp_info_cmp(pv, cpv) == INFO_BETTER ||
901: (bstp_same_bridgeid(pv->pv_dbridge_id, cpv->pv_dbridge_id) &&
902: (cpv->pv_dport_id & 0xfff) == (pv->pv_dport_id & 0xfff)))
903: return (1);
904: return (0);
905: }
906:
907: void
908: bstp_assign_roles(struct bstp_state *bs)
909: {
910: struct bstp_port *bp, *rbp = NULL;
911: struct bstp_pri_vector pv;
912:
913: /* default to our priority vector */
914: bs->bs_root_pv = bs->bs_bridge_pv;
915: bs->bs_root_msg_age = 0;
916: bs->bs_root_max_age = bs->bs_bridge_max_age;
917: bs->bs_root_fdelay = bs->bs_bridge_fdelay;
918: bs->bs_root_htime = bs->bs_bridge_htime;
919: bs->bs_root_port = NULL;
920:
921: /* check if any recieved info supersedes us */
922: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
923: if (bp->bp_infois != BSTP_INFO_RECIEVED)
924: continue;
925:
926: pv = bp->bp_port_pv;
927: pv.pv_cost += bp->bp_path_cost;
928:
929: /*
930: * The root priority vector is the best of the set comprising
931: * the bridge priority vector plus all root path priority
932: * vectors whose bridge address is not equal to us.
933: */
934: if (bstp_same_bridgeid(pv.pv_dbridge_id,
935: bs->bs_bridge_pv.pv_dbridge_id) == 0 &&
936: bstp_info_cmp(&bs->bs_root_pv, &pv) == INFO_BETTER) {
937: /* the port vector replaces the root */
938: bs->bs_root_pv = pv;
939: bs->bs_root_msg_age = bp->bp_port_msg_age +
940: BSTP_MESSAGE_AGE_INCR;
941: bs->bs_root_max_age = bp->bp_port_max_age;
942: bs->bs_root_fdelay = bp->bp_port_fdelay;
943: bs->bs_root_htime = bp->bp_port_htime;
944: rbp = bp;
945: }
946: }
947:
948: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
949: /* calculate the port designated vector */
950: bp->bp_desg_pv.pv_root_id = bs->bs_root_pv.pv_root_id;
951: bp->bp_desg_pv.pv_cost = bs->bs_root_pv.pv_cost;
952: bp->bp_desg_pv.pv_dbridge_id = bs->bs_bridge_pv.pv_dbridge_id;
953: bp->bp_desg_pv.pv_dport_id = bp->bp_port_id;
954: bp->bp_desg_pv.pv_port_id = bp->bp_port_id;
955:
956: /* calculate designated times */
957: bp->bp_desg_msg_age = bs->bs_root_msg_age;
958: bp->bp_desg_max_age = bs->bs_root_max_age;
959: bp->bp_desg_fdelay = bs->bs_root_fdelay;
960: bp->bp_desg_htime = bs->bs_bridge_htime;
961:
962:
963: switch (bp->bp_infois) {
964: case BSTP_INFO_DISABLED:
965: bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
966: break;
967:
968: case BSTP_INFO_AGED:
969: bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
970: bstp_update_info(bp);
971: break;
972:
973: case BSTP_INFO_MINE:
974: bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
975: /* update the port info if stale */
976: if (bstp_info_cmp(&bp->bp_port_pv,
977: &bp->bp_desg_pv) != INFO_SAME ||
978: (rbp != NULL &&
979: (bp->bp_port_msg_age != rbp->bp_port_msg_age ||
980: bp->bp_port_max_age != rbp->bp_port_max_age ||
981: bp->bp_port_fdelay != rbp->bp_port_fdelay ||
982: bp->bp_port_htime != rbp->bp_port_htime)))
983: bstp_update_info(bp);
984: break;
985:
986: case BSTP_INFO_RECIEVED:
987: if (bp == rbp) {
988: /*
989: * root priority is derived from this
990: * port, make it the root port.
991: */
992: bstp_set_port_role(bp, BSTP_ROLE_ROOT);
993: bs->bs_root_port = bp;
994: } else if (bstp_info_cmp(&bp->bp_port_pv,
995: &bp->bp_desg_pv) == INFO_BETTER) {
996: /*
997: * the port priority is lower than the root
998: * port.
999: */
1000: bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
1001: bstp_update_info(bp);
1002: } else {
1003: if (bstp_same_bridgeid(
1004: bp->bp_port_pv.pv_dbridge_id,
1005: bs->bs_bridge_pv.pv_dbridge_id)) {
1006: /*
1007: * the designated bridge refers to
1008: * another port on this bridge.
1009: */
1010: bstp_set_port_role(bp,
1011: BSTP_ROLE_BACKUP);
1012: } else {
1013: /*
1014: * the port is an inferior path to the
1015: * root bridge.
1016: */
1017: bstp_set_port_role(bp,
1018: BSTP_ROLE_ALTERNATE);
1019: }
1020: }
1021: break;
1022: }
1023: }
1024: }
1025:
1026: void
1027: bstp_update_state(struct bstp_state *bs, struct bstp_port *bp)
1028: {
1029: struct bstp_port *bp2;
1030: int synced;
1031:
1032: /* check if all the ports have syncronised again */
1033: if (!bs->bs_allsynced) {
1034: synced = 1;
1035: LIST_FOREACH(bp2, &bs->bs_bplist, bp_next) {
1036: if (!(bp->bp_synced ||
1037: bp->bp_role == BSTP_ROLE_ROOT)) {
1038: synced = 0;
1039: break;
1040: }
1041: }
1042: bs->bs_allsynced = synced;
1043: }
1044:
1045: bstp_update_roles(bs, bp);
1046: bstp_update_tc(bp);
1047: }
1048:
1049: void
1050: bstp_update_roles(struct bstp_state *bs, struct bstp_port *bp)
1051: {
1052: switch (bp->bp_role) {
1053: case BSTP_ROLE_DISABLED:
1054: /* Clear any flags if set */
1055: if (bp->bp_sync || !bp->bp_synced || bp->bp_reroot) {
1056: bp->bp_sync = 0;
1057: bp->bp_synced = 1;
1058: bp->bp_reroot = 0;
1059: }
1060: break;
1061:
1062: case BSTP_ROLE_ALTERNATE:
1063: case BSTP_ROLE_BACKUP:
1064: if ((bs->bs_allsynced && !bp->bp_agree) ||
1065: (bp->bp_proposed && bp->bp_agree)) {
1066: bp->bp_proposed = 0;
1067: bp->bp_agree = 1;
1068: bp->bp_flags |= BSTP_PORT_NEWINFO;
1069: DPRINTF("%s -> ALTERNATE_AGREED\n",
1070: bp->bp_ifp->if_xname);
1071: }
1072:
1073: if (bp->bp_proposed && !bp->bp_agree) {
1074: bstp_set_all_sync(bs);
1075: bp->bp_proposed = 0;
1076: DPRINTF("%s -> ALTERNATE_PROPOSED\n",
1077: bp->bp_ifp->if_xname);
1078: }
1079:
1080: /* Clear any flags if set */
1081: if (bp->bp_sync || !bp->bp_synced || bp->bp_reroot) {
1082: bp->bp_sync = 0;
1083: bp->bp_synced = 1;
1084: bp->bp_reroot = 0;
1085: DPRINTF("%s -> ALTERNATE_PORT\n", bp->bp_ifp->if_xname);
1086: }
1087: break;
1088:
1089: case BSTP_ROLE_ROOT:
1090: if (bp->bp_state != BSTP_IFSTATE_FORWARDING && !bp->bp_reroot) {
1091: bstp_set_all_reroot(bs);
1092: DPRINTF("%s -> ROOT_REROOT\n", bp->bp_ifp->if_xname);
1093: }
1094:
1095: if ((bs->bs_allsynced && !bp->bp_agree) ||
1096: (bp->bp_proposed && bp->bp_agree)) {
1097: bp->bp_proposed = 0;
1098: bp->bp_sync = 0;
1099: bp->bp_agree = 1;
1100: bp->bp_flags |= BSTP_PORT_NEWINFO;
1101: DPRINTF("%s -> ROOT_AGREED\n", bp->bp_ifp->if_xname);
1102: }
1103:
1104: if (bp->bp_proposed && !bp->bp_agree) {
1105: bstp_set_all_sync(bs);
1106: bp->bp_proposed = 0;
1107: DPRINTF("%s -> ROOT_PROPOSED\n", bp->bp_ifp->if_xname);
1108: }
1109:
1110: if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
1111: (bp->bp_forward_delay_timer.active == 0 ||
1112: (bstp_rerooted(bs, bp) &&
1113: bp->bp_recent_backup_timer.active == 0 &&
1114: bp->bp_protover == BSTP_PROTO_RSTP))) {
1115: switch (bp->bp_state) {
1116: case BSTP_IFSTATE_DISCARDING:
1117: bstp_set_port_state(bp, BSTP_IFSTATE_LEARNING);
1118: break;
1119: case BSTP_IFSTATE_LEARNING:
1120: bstp_set_port_state(bp,
1121: BSTP_IFSTATE_FORWARDING);
1122: break;
1123: }
1124: }
1125:
1126: if (bp->bp_state == BSTP_IFSTATE_FORWARDING && bp->bp_reroot) {
1127: bp->bp_reroot = 0;
1128: DPRINTF("%s -> ROOT_REROOTED\n", bp->bp_ifp->if_xname);
1129: }
1130: break;
1131:
1132: case BSTP_ROLE_DESIGNATED:
1133: if (bp->bp_recent_root_timer.active == 0 && bp->bp_reroot) {
1134: bp->bp_reroot = 0;
1135: DPRINTF("%s -> DESIGNATED_RETIRED\n",
1136: bp->bp_ifp->if_xname);
1137: }
1138:
1139: if ((bp->bp_state == BSTP_IFSTATE_DISCARDING &&
1140: !bp->bp_synced) || (bp->bp_agreed && !bp->bp_synced) ||
1141: (bp->bp_operedge && !bp->bp_synced) ||
1142: (bp->bp_sync && bp->bp_synced)) {
1143: bstp_timer_stop(&bp->bp_recent_root_timer);
1144: bp->bp_synced = 1;
1145: bp->bp_sync = 0;
1146: DPRINTF("%s -> DESIGNATED_SYNCED\n",
1147: bp->bp_ifp->if_xname);
1148: }
1149:
1150: if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
1151: !bp->bp_agreed && !bp->bp_proposing &&
1152: !bp->bp_operedge) {
1153: bp->bp_proposing = 1;
1154: bp->bp_flags |= BSTP_PORT_NEWINFO;
1155: bstp_timer_start(&bp->bp_edge_delay_timer,
1156: (bp->bp_ptp_link ? BSTP_DEFAULT_MIGRATE_DELAY :
1157: bp->bp_desg_max_age));
1158: DPRINTF("%s -> DESIGNATED_PROPOSE\n",
1159: bp->bp_ifp->if_xname);
1160: }
1161:
1162: if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
1163: (bp->bp_forward_delay_timer.active == 0 || bp->bp_agreed ||
1164: bp->bp_operedge) &&
1165: (bp->bp_recent_root_timer.active == 0 || !bp->bp_reroot) &&
1166: !bp->bp_sync) {
1167: if (bp->bp_agreed)
1168: DPRINTF("%s -> AGREED\n", bp->bp_ifp->if_xname);
1169: /*
1170: * If agreed|operedge then go straight to forwarding,
1171: * otherwise follow discard -> learn -> forward.
1172: */
1173: if (bp->bp_agreed || bp->bp_operedge ||
1174: bp->bp_state == BSTP_IFSTATE_LEARNING) {
1175: bstp_set_port_state(bp,
1176: BSTP_IFSTATE_FORWARDING);
1177: bp->bp_agreed = bp->bp_protover;
1178: } else if (bp->bp_state == BSTP_IFSTATE_DISCARDING)
1179: bstp_set_port_state(bp, BSTP_IFSTATE_LEARNING);
1180: }
1181:
1182: if (((bp->bp_sync && !bp->bp_synced) ||
1183: (bp->bp_reroot && bp->bp_recent_root_timer.active) ||
1184: (bp->bp_flags & BSTP_PORT_DISPUTED)) && !bp->bp_operedge &&
1185: bp->bp_state != BSTP_IFSTATE_DISCARDING) {
1186: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
1187: bp->bp_flags &= ~BSTP_PORT_DISPUTED;
1188: bstp_timer_start(&bp->bp_forward_delay_timer,
1189: bp->bp_protover == BSTP_PROTO_RSTP ?
1190: bp->bp_desg_htime : bp->bp_desg_fdelay);
1191: DPRINTF("%s -> DESIGNATED_DISCARD\n",
1192: bp->bp_ifp->if_xname);
1193: }
1194: break;
1195: }
1196:
1197: if (bp->bp_flags & BSTP_PORT_NEWINFO)
1198: bstp_transmit(bs, bp);
1199: }
1200:
1201: void
1202: bstp_update_tc(struct bstp_port *bp)
1203: {
1204: switch (bp->bp_tcstate) {
1205: case BSTP_TCSTATE_ACTIVE:
1206: if ((bp->bp_role != BSTP_ROLE_DESIGNATED &&
1207: bp->bp_role != BSTP_ROLE_ROOT) || bp->bp_operedge)
1208: bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
1209:
1210: if (bp->bp_rcvdtcn)
1211: bstp_set_port_tc(bp, BSTP_TCSTATE_TCN);
1212: if (bp->bp_rcvdtc)
1213: bstp_set_port_tc(bp, BSTP_TCSTATE_TC);
1214:
1215: if (bp->bp_tc_prop && !bp->bp_operedge)
1216: bstp_set_port_tc(bp, BSTP_TCSTATE_PROPAG);
1217:
1218: if (bp->bp_rcvdtca)
1219: bstp_set_port_tc(bp, BSTP_TCSTATE_ACK);
1220: break;
1221:
1222: case BSTP_TCSTATE_INACTIVE:
1223: if ((bp->bp_state == BSTP_IFSTATE_LEARNING ||
1224: bp->bp_state == BSTP_IFSTATE_FORWARDING) &&
1225: bp->bp_fdbflush == 0)
1226: bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
1227: break;
1228:
1229: case BSTP_TCSTATE_LEARNING:
1230: if (bp->bp_rcvdtc || bp->bp_rcvdtcn || bp->bp_rcvdtca ||
1231: bp->bp_tc_prop)
1232: bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
1233: else if (bp->bp_role != BSTP_ROLE_DESIGNATED &&
1234: bp->bp_role != BSTP_ROLE_ROOT &&
1235: bp->bp_state == BSTP_IFSTATE_DISCARDING)
1236: bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
1237:
1238: if ((bp->bp_role == BSTP_ROLE_DESIGNATED ||
1239: bp->bp_role == BSTP_ROLE_ROOT) &&
1240: bp->bp_state == BSTP_IFSTATE_FORWARDING &&
1241: !bp->bp_operedge)
1242: bstp_set_port_tc(bp, BSTP_TCSTATE_DETECTED);
1243: break;
1244:
1245: /* these are transient states and go straight back to ACTIVE */
1246: case BSTP_TCSTATE_DETECTED:
1247: case BSTP_TCSTATE_TCN:
1248: case BSTP_TCSTATE_TC:
1249: case BSTP_TCSTATE_PROPAG:
1250: case BSTP_TCSTATE_ACK:
1251: DPRINTF("Invalid TC state for %s\n",
1252: bp->bp_ifp->if_xname);
1253: break;
1254: }
1255:
1256: }
1257:
1258: void
1259: bstp_update_info(struct bstp_port *bp)
1260: {
1261: struct bstp_state *bs = bp->bp_bs;
1262:
1263: bp->bp_proposing = 0;
1264: bp->bp_proposed = 0;
1265:
1266: if (bp->bp_agreed && !bstp_pdu_bettersame(bp, BSTP_INFO_MINE))
1267: bp->bp_agreed = 0;
1268:
1269: if (bp->bp_synced && !bp->bp_agreed) {
1270: bp->bp_synced = 0;
1271: bs->bs_allsynced = 0;
1272: }
1273:
1274: /* copy the designated pv to the port */
1275: bp->bp_port_pv = bp->bp_desg_pv;
1276: bp->bp_port_msg_age = bp->bp_desg_msg_age;
1277: bp->bp_port_max_age = bp->bp_desg_max_age;
1278: bp->bp_port_fdelay = bp->bp_desg_fdelay;
1279: bp->bp_port_htime = bp->bp_desg_htime;
1280: bp->bp_infois = BSTP_INFO_MINE;
1281:
1282: /* Set transmit flag but do not immediately send */
1283: bp->bp_flags |= BSTP_PORT_NEWINFO;
1284: }
1285:
1286: /* set tcprop on every port other than the caller */
1287: void
1288: bstp_set_other_tcprop(struct bstp_port *bp)
1289: {
1290: struct bstp_state *bs = bp->bp_bs;
1291: struct bstp_port *bp2;
1292:
1293: LIST_FOREACH(bp2, &bs->bs_bplist, bp_next) {
1294: if (bp2 == bp)
1295: continue;
1296: bp2->bp_tc_prop = 1;
1297: }
1298: }
1299:
1300: void
1301: bstp_set_all_reroot(struct bstp_state *bs)
1302: {
1303: struct bstp_port *bp;
1304:
1305: LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
1306: bp->bp_reroot = 1;
1307: }
1308:
1309: void
1310: bstp_set_all_sync(struct bstp_state *bs)
1311: {
1312: struct bstp_port *bp;
1313:
1314: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
1315: bp->bp_sync = 1;
1316: bp->bp_synced = 0; /* Not explicit in spec */
1317: }
1318:
1319: bs->bs_allsynced = 0;
1320: }
1321:
1322: void
1323: bstp_set_port_state(struct bstp_port *bp, int state)
1324: {
1325: if (bp->bp_state == state)
1326: return;
1327:
1328: bp->bp_state = state;
1329:
1330: switch (bp->bp_state) {
1331: case BSTP_IFSTATE_DISCARDING:
1332: DPRINTF("state changed to DISCARDING on %s\n",
1333: bp->bp_ifp->if_xname);
1334: break;
1335:
1336: case BSTP_IFSTATE_LEARNING:
1337: DPRINTF("state changed to LEARNING on %s\n",
1338: bp->bp_ifp->if_xname);
1339:
1340: bstp_timer_start(&bp->bp_forward_delay_timer,
1341: bp->bp_protover == BSTP_PROTO_RSTP ?
1342: bp->bp_desg_htime : bp->bp_desg_fdelay);
1343: break;
1344:
1345: case BSTP_IFSTATE_FORWARDING:
1346: DPRINTF("state changed to FORWARDING on %s\n",
1347: bp->bp_ifp->if_xname);
1348:
1349: bstp_timer_stop(&bp->bp_forward_delay_timer);
1350: /* Record that we enabled forwarding */
1351: bp->bp_forward_transitions++;
1352: break;
1353: }
1354: }
1355:
1356: void
1357: bstp_set_port_role(struct bstp_port *bp, int role)
1358: {
1359: struct bstp_state *bs = bp->bp_bs;
1360:
1361: if (bp->bp_role == role)
1362: return;
1363:
1364: /* perform pre-change tasks */
1365: switch (bp->bp_role) {
1366: case BSTP_ROLE_DISABLED:
1367: bstp_timer_start(&bp->bp_forward_delay_timer,
1368: bp->bp_desg_max_age);
1369: break;
1370:
1371: case BSTP_ROLE_BACKUP:
1372: bstp_timer_start(&bp->bp_recent_backup_timer,
1373: bp->bp_desg_htime * 2);
1374: /* FALLTHROUGH */
1375: case BSTP_ROLE_ALTERNATE:
1376: bstp_timer_start(&bp->bp_forward_delay_timer,
1377: bp->bp_desg_fdelay);
1378: bp->bp_sync = 0;
1379: bp->bp_synced = 1;
1380: bp->bp_reroot = 0;
1381: break;
1382:
1383: case BSTP_ROLE_ROOT:
1384: bstp_timer_start(&bp->bp_recent_root_timer,
1385: BSTP_DEFAULT_FORWARD_DELAY);
1386: break;
1387: }
1388:
1389: bp->bp_role = role;
1390: /* clear values not carried between roles */
1391: bp->bp_proposing = 0;
1392: bs->bs_allsynced = 0;
1393:
1394: /* initialise the new role */
1395: switch (bp->bp_role) {
1396: case BSTP_ROLE_DISABLED:
1397: case BSTP_ROLE_ALTERNATE:
1398: case BSTP_ROLE_BACKUP:
1399: DPRINTF("%s role -> ALT/BACK/DISABLED\n",
1400: bp->bp_ifp->if_xname);
1401: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
1402: bstp_timer_stop(&bp->bp_recent_root_timer);
1403: bstp_timer_latch(&bp->bp_forward_delay_timer);
1404: bp->bp_sync = 0;
1405: bp->bp_synced = 1;
1406: bp->bp_reroot = 0;
1407: break;
1408:
1409: case BSTP_ROLE_ROOT:
1410: DPRINTF("%s role -> ROOT\n",
1411: bp->bp_ifp->if_xname);
1412: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
1413: bstp_timer_latch(&bp->bp_recent_root_timer);
1414: bp->bp_proposing = 0;
1415: break;
1416:
1417: case BSTP_ROLE_DESIGNATED:
1418: DPRINTF("%s role -> DESIGNATED\n",
1419: bp->bp_ifp->if_xname);
1420: bstp_timer_start(&bp->bp_hello_timer,
1421: bp->bp_desg_htime);
1422: bp->bp_agree = 0;
1423: break;
1424: }
1425:
1426: /* let the TC state know that the role changed */
1427: bstp_update_tc(bp);
1428: }
1429:
1430: void
1431: bstp_set_port_proto(struct bstp_port *bp, int proto)
1432: {
1433: struct bstp_state *bs = bp->bp_bs;
1434:
1435: /* supported protocol versions */
1436: switch (proto) {
1437: case BSTP_PROTO_STP:
1438: /* we can downgrade protocols only */
1439: bstp_timer_stop(&bp->bp_migrate_delay_timer);
1440: /* clear unsupported features */
1441: bp->bp_operedge = 0;
1442: break;
1443:
1444: case BSTP_PROTO_RSTP:
1445: bstp_timer_start(&bp->bp_migrate_delay_timer,
1446: bs->bs_migration_delay);
1447: break;
1448:
1449: default:
1450: DPRINTF("Unsupported STP version %d\n", proto);
1451: return;
1452: }
1453:
1454: bp->bp_protover = proto;
1455: bp->bp_flags &= ~BSTP_PORT_CANMIGRATE;
1456: }
1457:
1458: void
1459: bstp_set_port_tc(struct bstp_port *bp, int state)
1460: {
1461: struct bstp_state *bs = bp->bp_bs;
1462:
1463: bp->bp_tcstate = state;
1464:
1465: /* initialise the new state */
1466: switch (bp->bp_tcstate) {
1467: case BSTP_TCSTATE_ACTIVE:
1468: DPRINTF("%s -> TC_ACTIVE\n", bp->bp_ifp->if_xname);
1469: /* nothing to do */
1470: break;
1471:
1472: case BSTP_TCSTATE_INACTIVE:
1473: bstp_timer_stop(&bp->bp_tc_timer);
1474: /* flush routes on the parent bridge */
1475: bp->bp_fdbflush = 1;
1476: bstp_notify_rtage(bp->bp_ifp, 0);
1477: bp->bp_tc_ack = 0;
1478: DPRINTF("%s -> TC_INACTIVE\n", bp->bp_ifp->if_xname);
1479: break;
1480:
1481: case BSTP_TCSTATE_LEARNING:
1482: bp->bp_rcvdtc = 0;
1483: bp->bp_rcvdtcn = 0;
1484: bp->bp_rcvdtca = 0;
1485: bp->bp_tc_prop = 0;
1486: DPRINTF("%s -> TC_LEARNING\n", bp->bp_ifp->if_xname);
1487: break;
1488:
1489: case BSTP_TCSTATE_DETECTED:
1490: bstp_set_timer_tc(bp);
1491: bstp_set_other_tcprop(bp);
1492: /* send out notification */
1493: bp->bp_flags |= BSTP_PORT_NEWINFO;
1494: bstp_transmit(bs, bp);
1495: getmicrotime(&bs->bs_last_tc_time);
1496: DPRINTF("%s -> TC_DETECTED\n", bp->bp_ifp->if_xname);
1497: bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
1498: break;
1499:
1500: case BSTP_TCSTATE_TCN:
1501: bstp_set_timer_tc(bp);
1502: DPRINTF("%s -> TC_TCN\n", bp->bp_ifp->if_xname);
1503: /* FALLTHROUGH */
1504: case BSTP_TCSTATE_TC:
1505: bp->bp_rcvdtc = 0;
1506: bp->bp_rcvdtcn = 0;
1507: if (bp->bp_role == BSTP_ROLE_DESIGNATED)
1508: bp->bp_tc_ack = 1;
1509:
1510: bstp_set_other_tcprop(bp);
1511: DPRINTF("%s -> TC_TC\n", bp->bp_ifp->if_xname);
1512: bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
1513: break;
1514:
1515: case BSTP_TCSTATE_PROPAG:
1516: /* flush routes on the parent bridge */
1517: bp->bp_fdbflush = 1;
1518: bstp_notify_rtage(bp->bp_ifp, 0);
1519: bp->bp_tc_prop = 0;
1520: bstp_set_timer_tc(bp);
1521: DPRINTF("%s -> TC_PROPAG\n", bp->bp_ifp->if_xname);
1522: bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
1523: break;
1524:
1525: case BSTP_TCSTATE_ACK:
1526: bstp_timer_stop(&bp->bp_tc_timer);
1527: bp->bp_rcvdtca = 0;
1528: DPRINTF("%s -> TC_ACK\n", bp->bp_ifp->if_xname);
1529: bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
1530: break;
1531: }
1532: }
1533:
1534: void
1535: bstp_set_timer_tc(struct bstp_port *bp)
1536: {
1537: struct bstp_state *bs = bp->bp_bs;
1538:
1539: if (bp->bp_tc_timer.active)
1540: return;
1541:
1542: switch (bp->bp_protover) {
1543: case BSTP_PROTO_RSTP:
1544: bstp_timer_start(&bp->bp_tc_timer,
1545: bp->bp_desg_htime + BSTP_TICK_VAL);
1546: bp->bp_flags |= BSTP_PORT_NEWINFO;
1547: break;
1548: case BSTP_PROTO_STP:
1549: bstp_timer_start(&bp->bp_tc_timer,
1550: bs->bs_root_max_age + bs->bs_root_fdelay);
1551: break;
1552: }
1553: }
1554:
1555: void
1556: bstp_set_timer_msgage(struct bstp_port *bp)
1557: {
1558: if (bp->bp_port_msg_age + BSTP_MESSAGE_AGE_INCR <=
1559: bp->bp_port_max_age) {
1560: bstp_timer_start(&bp->bp_message_age_timer,
1561: bp->bp_port_htime * 3);
1562: } else
1563: /* expires immediately */
1564: bstp_timer_start(&bp->bp_message_age_timer, 0);
1565: }
1566:
1567: int
1568: bstp_rerooted(struct bstp_state *bs, struct bstp_port *bp)
1569: {
1570: struct bstp_port *bp2;
1571: int rr_set = 0;
1572:
1573: LIST_FOREACH(bp2, &bs->bs_bplist, bp_next) {
1574: if (bp2 == bp)
1575: continue;
1576: if (bp2->bp_recent_root_timer.active) {
1577: rr_set = 1;
1578: break;
1579: }
1580: }
1581: return (!rr_set);
1582: }
1583:
1584: /*
1585: * Calculate the path cost according to the link speed.
1586: */
1587: u_int32_t
1588: bstp_calc_path_cost(struct bstp_port *bp)
1589: {
1590: struct ifnet *ifp = bp->bp_ifp;
1591: u_int32_t path_cost;
1592:
1593: /* If the priority has been manually set then retain the value */
1594: if (bp->bp_flags & BSTP_PORT_ADMCOST)
1595: return bp->bp_path_cost;
1596:
1597: if (ifp->if_baudrate < 1000)
1598: return (BSTP_DEFAULT_PATH_COST);
1599:
1600: /* formula from section 17.14, IEEE Std 802.1D-2004 */
1601: path_cost = 20000000000ULL / (ifp->if_baudrate / 1000);
1602:
1603: if (path_cost > BSTP_MAX_PATH_COST)
1604: path_cost = BSTP_MAX_PATH_COST;
1605:
1606: /* STP compat mode only uses 16 bits of the 32 */
1607: if (bp->bp_protover == BSTP_PROTO_STP && path_cost > 65535)
1608: path_cost = 65535;
1609:
1610: return (path_cost);
1611: }
1612:
1613: void
1614: bstp_notify_rtage(void *arg, int pending)
1615: {
1616: struct bstp_port *bp = (struct bstp_port *)arg;
1617: int age = 0;
1618:
1619: splassert(IPL_NET);
1620:
1621: switch (bp->bp_protover) {
1622: case BSTP_PROTO_STP:
1623: /* convert to seconds */
1624: age = bp->bp_desg_fdelay / BSTP_TICK_VAL;
1625: break;
1626: case BSTP_PROTO_RSTP:
1627: age = 0;
1628: break;
1629: }
1630:
1631: if (bp->bp_active == 1)
1632: bridge_rtagenode(bp->bp_ifp, age);
1633:
1634: /* flush is complete */
1635: bp->bp_fdbflush = 0;
1636: }
1637:
1638: void
1639: bstp_ifstate(void *arg)
1640: {
1641: struct ifnet *ifp = (struct ifnet *)arg;
1642: struct bridge_softc *sc;
1643: struct bridge_iflist *p;
1644: struct bstp_port *bp;
1645: struct bstp_state *bs;
1646: int s;
1647:
1648: if (ifp->if_type == IFT_BRIDGE)
1649: return;
1650: sc = (struct bridge_softc *)ifp->if_bridge;
1651:
1652: s = splnet();
1653: LIST_FOREACH(p, &sc->sc_iflist, next) {
1654: if ((p->bif_flags & IFBIF_STP) == 0)
1655: continue;
1656: if (p->ifp == ifp)
1657: break;
1658: }
1659: if (p == LIST_END(&sc->sc_iflist))
1660: goto done;
1661: if ((bp = p->bif_stp) == NULL)
1662: goto done;
1663: if ((bs = bp->bp_bs) == NULL)
1664: goto done;
1665:
1666: /* update the link state */
1667: bstp_ifupdstatus(bs, bp);
1668: bstp_update_state(bs, bp);
1669: done:
1670: splx(s);
1671: }
1672:
1673: void
1674: bstp_ifupdstatus(struct bstp_state *bs, struct bstp_port *bp)
1675: {
1676: struct ifnet *ifp = bp->bp_ifp;
1677:
1678: if (ifp == NULL)
1679: return;
1680:
1681: bp->bp_path_cost = bstp_calc_path_cost(bp);
1682:
1683: if ((ifp->if_flags & IFF_UP) &&
1684: ifp->if_link_state != LINK_STATE_DOWN) {
1685: if (bp->bp_flags & BSTP_PORT_AUTOPTP) {
1686: /* A full-duplex link is assumed to be ptp */
1687: bp->bp_ptp_link = ifp->if_link_state ==
1688: LINK_STATE_FULL_DUPLEX ? 1 : 0;
1689: }
1690:
1691: if (bp->bp_infois == BSTP_INFO_DISABLED)
1692: bstp_enable_port(bs, bp);
1693: } else {
1694: if (bp->bp_infois != BSTP_INFO_DISABLED)
1695: bstp_disable_port(bs, bp);
1696: }
1697: }
1698:
1699: void
1700: bstp_enable_port(struct bstp_state *bs, struct bstp_port *bp)
1701: {
1702: bp->bp_infois = BSTP_INFO_AGED;
1703: bstp_assign_roles(bs);
1704: }
1705:
1706: void
1707: bstp_disable_port(struct bstp_state *bs, struct bstp_port *bp)
1708: {
1709: bp->bp_infois = BSTP_INFO_DISABLED;
1710: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
1711: bstp_assign_roles(bs);
1712: }
1713:
1714: void
1715: bstp_tick(void *arg)
1716: {
1717: struct bstp_state *bs = (struct bstp_state *)arg;
1718: struct bstp_port *bp;
1719: int s;
1720:
1721: s = splnet();
1722: if ((bs->bs_ifflags & IFF_RUNNING) == 0) {
1723: splx(s);
1724: return;
1725: }
1726:
1727: /* slow timer to catch missed link events */
1728: if (bstp_timer_expired(&bs->bs_link_timer)) {
1729: LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
1730: bstp_ifupdstatus(bs, bp);
1731: bstp_timer_start(&bs->bs_link_timer, BSTP_LINK_TIMER);
1732: }
1733:
1734: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
1735: /* no events need to happen for these */
1736: bstp_timer_expired(&bp->bp_tc_timer);
1737: bstp_timer_expired(&bp->bp_recent_root_timer);
1738: bstp_timer_expired(&bp->bp_forward_delay_timer);
1739: bstp_timer_expired(&bp->bp_recent_backup_timer);
1740:
1741: if (bstp_timer_expired(&bp->bp_hello_timer))
1742: bstp_hello_timer_expiry(bs, bp);
1743:
1744: if (bstp_timer_expired(&bp->bp_message_age_timer))
1745: bstp_message_age_expiry(bs, bp);
1746:
1747: if (bstp_timer_expired(&bp->bp_migrate_delay_timer))
1748: bstp_migrate_delay_expiry(bs, bp);
1749:
1750: if (bstp_timer_expired(&bp->bp_edge_delay_timer))
1751: bstp_edge_delay_expiry(bs, bp);
1752:
1753: /* update the various state machines for the port */
1754: bstp_update_state(bs, bp);
1755:
1756: if (bp->bp_txcount > 0)
1757: bp->bp_txcount--;
1758: }
1759:
1760: if (bs->bs_ifp->if_flags & IFF_RUNNING)
1761: timeout_add(&bs->bs_bstptimeout, hz);
1762:
1763: splx(s);
1764: }
1765:
1766: void
1767: bstp_timer_start(struct bstp_timer *t, u_int16_t v)
1768: {
1769: t->value = v;
1770: t->active = 1;
1771: t->latched = 0;
1772: }
1773:
1774: void
1775: bstp_timer_stop(struct bstp_timer *t)
1776: {
1777: t->value = 0;
1778: t->active = 0;
1779: t->latched = 0;
1780: }
1781:
1782: void
1783: bstp_timer_latch(struct bstp_timer *t)
1784: {
1785: t->latched = 1;
1786: t->active = 1;
1787: }
1788:
1789: int
1790: bstp_timer_expired(struct bstp_timer *t)
1791: {
1792: if (t->active == 0 || t->latched)
1793: return (0);
1794: t->value -= BSTP_TICK_VAL;
1795: if (t->value <= 0) {
1796: bstp_timer_stop(t);
1797: return (1);
1798: }
1799: return (0);
1800: }
1801:
1802: void
1803: bstp_hello_timer_expiry(struct bstp_state *bs, struct bstp_port *bp)
1804: {
1805: if ((bp->bp_flags & BSTP_PORT_NEWINFO) ||
1806: bp->bp_role == BSTP_ROLE_DESIGNATED ||
1807: (bp->bp_role == BSTP_ROLE_ROOT &&
1808: bp->bp_tc_timer.active == 1)) {
1809: bstp_timer_start(&bp->bp_hello_timer, bp->bp_desg_htime);
1810: bp->bp_flags |= BSTP_PORT_NEWINFO;
1811: bstp_transmit(bs, bp);
1812: }
1813: }
1814:
1815: void
1816: bstp_message_age_expiry(struct bstp_state *bs, struct bstp_port *bp)
1817: {
1818: if (bp->bp_infois == BSTP_INFO_RECIEVED) {
1819: bp->bp_infois = BSTP_INFO_AGED;
1820: bstp_assign_roles(bs);
1821: DPRINTF("aged info on %s\n", bp->bp_ifp->if_xname);
1822: }
1823: }
1824:
1825: void
1826: bstp_migrate_delay_expiry(struct bstp_state *bs, struct bstp_port *bp)
1827: {
1828: bp->bp_flags |= BSTP_PORT_CANMIGRATE;
1829: }
1830:
1831: void
1832: bstp_edge_delay_expiry(struct bstp_state *bs, struct bstp_port *bp)
1833: {
1834: if ((bp->bp_flags & BSTP_PORT_AUTOEDGE) &&
1835: bp->bp_protover == BSTP_PROTO_RSTP && bp->bp_proposing &&
1836: bp->bp_role == BSTP_ROLE_DESIGNATED)
1837: bp->bp_operedge = 1;
1838: }
1839:
1840: int
1841: bstp_addr_cmp(const u_int8_t *a, const u_int8_t *b)
1842: {
1843: int i, d;
1844:
1845: for (i = 0, d = 0; i < ETHER_ADDR_LEN && d == 0; i++) {
1846: d = ((int)a[i]) - ((int)b[i]);
1847: }
1848:
1849: return (d);
1850: }
1851:
1852: /*
1853: * compare the bridge address component of the bridgeid
1854: */
1855: int
1856: bstp_same_bridgeid(u_int64_t id1, u_int64_t id2)
1857: {
1858: u_char addr1[ETHER_ADDR_LEN];
1859: u_char addr2[ETHER_ADDR_LEN];
1860:
1861: PV2ADDR(id1, addr1);
1862: PV2ADDR(id2, addr2);
1863:
1864: if (bstp_addr_cmp(addr1, addr2) == 0)
1865: return (1);
1866:
1867: return (0);
1868: }
1869:
1870: void
1871: bstp_initialization(struct bstp_state *bs)
1872: {
1873: struct bstp_port *bp;
1874: struct ifnet *ifp, *mif;
1875: u_char *e_addr;
1876:
1877: if (LIST_EMPTY(&bs->bs_bplist)) {
1878: bstp_stop(bs);
1879: return;
1880: }
1881:
1882: mif = NULL;
1883: /*
1884: * Search through the Ethernet interfaces and find the one
1885: * with the lowest value. The adapter which we take the MAC
1886: * address from does not need to be part of the bridge, it just
1887: * needs to be a unique value. It is not possible for mif to be
1888: * null, at this point we have at least one STP port and hence
1889: * at least one NIC.
1890: */
1891: TAILQ_FOREACH(ifp, &ifnet, if_list) {
1892: if (ifp->if_type != IFT_ETHER)
1893: continue;
1894: if (mif == NULL) {
1895: mif = ifp;
1896: continue;
1897: }
1898: if (bstp_addr_cmp(LLADDR(ifp->if_sadl),
1899: LLADDR(mif->if_sadl)) < 0) {
1900: mif = ifp;
1901: continue;
1902: }
1903: }
1904:
1905: e_addr = LLADDR(mif->if_sadl);
1906: bs->bs_bridge_pv.pv_dbridge_id =
1907: (((u_int64_t)bs->bs_bridge_priority) << 48) |
1908: (((u_int64_t)e_addr[0]) << 40) |
1909: (((u_int64_t)e_addr[1]) << 32) |
1910: (((u_int64_t)e_addr[2]) << 24) |
1911: (((u_int64_t)e_addr[3]) << 16) |
1912: (((u_int64_t)e_addr[4]) << 8) |
1913: (((u_int64_t)e_addr[5]));
1914:
1915: bs->bs_bridge_pv.pv_root_id = bs->bs_bridge_pv.pv_dbridge_id;
1916: bs->bs_bridge_pv.pv_cost = 0;
1917: bs->bs_bridge_pv.pv_dport_id = 0;
1918: bs->bs_bridge_pv.pv_port_id = 0;
1919:
1920: if (!timeout_initialized(&bs->bs_bstptimeout))
1921: timeout_set(&bs->bs_bstptimeout, bstp_tick, bs);
1922: if (bs->bs_ifflags & IFF_RUNNING &&
1923: !timeout_pending(&bs->bs_bstptimeout))
1924: timeout_add(&bs->bs_bstptimeout, hz);
1925:
1926: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
1927: bp->bp_port_id = (bp->bp_priority << 8) |
1928: (bp->bp_ifp->if_index & 0xfff);
1929: bstp_ifupdstatus(bs, bp);
1930: }
1931:
1932: bstp_assign_roles(bs);
1933: bstp_timer_start(&bs->bs_link_timer, BSTP_LINK_TIMER);
1934: }
1935:
1936: struct bstp_state *
1937: bstp_create(struct ifnet *ifp)
1938: {
1939: struct bstp_state *bs;
1940: int s;
1941:
1942: s = splnet();
1943: bs = (struct bstp_state *)malloc(sizeof(*bs), M_DEVBUF, M_WAITOK);
1944: bzero(bs, sizeof(*bs));
1945: LIST_INIT(&bs->bs_bplist);
1946:
1947: bs->bs_ifp = ifp;
1948: bs->bs_bridge_max_age = BSTP_DEFAULT_MAX_AGE;
1949: bs->bs_bridge_htime = BSTP_DEFAULT_HELLO_TIME;
1950: bs->bs_bridge_fdelay = BSTP_DEFAULT_FORWARD_DELAY;
1951: bs->bs_bridge_priority = BSTP_DEFAULT_BRIDGE_PRIORITY;
1952: bs->bs_hold_time = BSTP_DEFAULT_HOLD_TIME;
1953: bs->bs_migration_delay = BSTP_DEFAULT_MIGRATE_DELAY;
1954: bs->bs_txholdcount = BSTP_DEFAULT_HOLD_COUNT;
1955: bs->bs_protover = BSTP_PROTO_RSTP; /* STP instead of RSTP? */
1956:
1957: getmicrotime(&bs->bs_last_tc_time);
1958:
1959: LIST_INSERT_HEAD(&bstp_list, bs, bs_list);
1960: splx(s);
1961:
1962: return (bs);
1963: }
1964:
1965: void
1966: bstp_destroy(struct bstp_state *bs)
1967: {
1968: int s;
1969:
1970: if (bs == NULL)
1971: return;
1972:
1973: if (!LIST_EMPTY(&bs->bs_bplist))
1974: panic("bstp still active");
1975:
1976: s = splnet();
1977: LIST_REMOVE(bs, bs_list);
1978: free(bs, M_DEVBUF);
1979: splx(s);
1980: }
1981:
1982: void
1983: bstp_stop(struct bstp_state *bs)
1984: {
1985: struct bstp_port *bp;
1986:
1987: LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
1988: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
1989:
1990: if (timeout_initialized(&bs->bs_bstptimeout) &&
1991: timeout_pending(&bs->bs_bstptimeout))
1992: timeout_del(&bs->bs_bstptimeout);
1993: }
1994:
1995: struct bstp_port *
1996: bstp_add(struct bstp_state *bs, struct ifnet *ifp)
1997: {
1998: struct bstp_port *bp;
1999:
2000: switch (ifp->if_type) {
2001: case IFT_ETHER: /* These can do spanning tree. */
2002: break;
2003: default:
2004: /* Nothing else can. */
2005: return (NULL);
2006: }
2007:
2008: bp = (struct bstp_port *)malloc(sizeof(*bp), M_DEVBUF, M_NOWAIT);
2009: if (bp == NULL)
2010: return (NULL);
2011: bzero(bp, sizeof(*bp));
2012:
2013: bp->bp_ifp = ifp;
2014: bp->bp_bs = bs;
2015: bp->bp_priority = BSTP_DEFAULT_PORT_PRIORITY;
2016: bp->bp_txcount = 0;
2017:
2018: /* Init state */
2019: bp->bp_infois = BSTP_INFO_DISABLED;
2020: bp->bp_flags = BSTP_PORT_AUTOEDGE | BSTP_PORT_AUTOPTP;
2021: bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
2022: bstp_set_port_proto(bp, bs->bs_protover);
2023: bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
2024: bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
2025: bp->bp_path_cost = bstp_calc_path_cost(bp);
2026:
2027: LIST_INSERT_HEAD(&bs->bs_bplist, bp, bp_next);
2028:
2029: bp->bp_active = 1;
2030: bp->bp_flags |= BSTP_PORT_NEWINFO;
2031: bstp_initialization(bs);
2032: bstp_update_roles(bs, bp);
2033:
2034: /* Register callback for physical link state changes */
2035: if (ifp->if_linkstatehooks != NULL)
2036: bp->bp_lhcookie = hook_establish(ifp->if_linkstatehooks, 1,
2037: bstp_ifstate, ifp);
2038:
2039: return (bp);
2040: }
2041:
2042: void
2043: bstp_delete(struct bstp_port *bp)
2044: {
2045: struct bstp_state *bs = bp->bp_bs;
2046: struct ifnet *ifp = bp->bp_ifp;
2047:
2048: if (!bp->bp_active)
2049: panic("not a bstp member");
2050:
2051: if (ifp != NULL && ifp->if_linkstatehooks != NULL)
2052: hook_disestablish(ifp->if_linkstatehooks, bp->bp_lhcookie);
2053:
2054: LIST_REMOVE(bp, bp_next);
2055: bp->bp_bs = NULL;
2056: bp->bp_active = 0;
2057: free(bp, M_DEVBUF);
2058: bstp_initialization(bs);
2059: }
2060:
2061: u_int8_t
2062: bstp_getstate(struct bstp_state *bs, struct bstp_port *bp)
2063: {
2064: u_int8_t state = bp->bp_state;
2065:
2066: if (bs->bs_protover != BSTP_PROTO_STP)
2067: return (state);
2068:
2069: /*
2070: * Translate RSTP roles and states to STP port states
2071: * (IEEE Std 802.1D-2004 Table 17-1).
2072: */
2073: if (bp->bp_role == BSTP_ROLE_DISABLED)
2074: state = BSTP_IFSTATE_DISABLED;
2075: else if (bp->bp_role == BSTP_ROLE_ALTERNATE ||
2076: bp->bp_role == BSTP_ROLE_BACKUP)
2077: state = BSTP_IFSTATE_BLOCKING;
2078: else if (state == BSTP_IFSTATE_DISCARDING)
2079: state = BSTP_IFSTATE_LISTENING;
2080:
2081: return (state);
2082: }
2083:
2084: void
2085: bstp_ifsflags(struct bstp_port *bp, u_int flags)
2086: {
2087: struct bstp_state *bs;
2088:
2089: if ((flags & IFBIF_STP) == 0)
2090: return;
2091: bs = bp->bp_bs;
2092:
2093: /*
2094: * Set edge status
2095: */
2096: if (flags & IFBIF_BSTP_AUTOEDGE) {
2097: if ((bp->bp_flags & BSTP_PORT_AUTOEDGE) == 0) {
2098: bp->bp_flags |= BSTP_PORT_AUTOEDGE;
2099:
2100: /* we may be able to transition straight to edge */
2101: if (bp->bp_edge_delay_timer.active == 0)
2102: bstp_edge_delay_expiry(bs, bp);
2103: }
2104: } else
2105: bp->bp_flags &= ~BSTP_PORT_AUTOEDGE;
2106:
2107: if (flags & IFBIF_BSTP_EDGE)
2108: bp->bp_operedge = 1;
2109: else
2110: bp->bp_operedge = 0;
2111:
2112: /*
2113: * Set point to point status
2114: */
2115: if (flags & IFBIF_BSTP_AUTOPTP) {
2116: if ((bp->bp_flags & BSTP_PORT_AUTOPTP) == 0) {
2117: bp->bp_flags |= BSTP_PORT_AUTOPTP;
2118:
2119: bstp_ifupdstatus(bs, bp);
2120: }
2121: } else
2122: bp->bp_flags &= ~BSTP_PORT_AUTOPTP;
2123:
2124: if (flags & IFBIF_BSTP_PTP)
2125: bp->bp_ptp_link = 1;
2126: else
2127: bp->bp_ptp_link = 0;
2128: }
2129:
2130: int
2131: bstp_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2132: {
2133: struct bridge_softc *sc = (struct bridge_softc *)ifp;
2134: struct bstp_state *bs = sc->sc_stp;
2135: struct ifbrparam *ifbp = (struct ifbrparam *)data;
2136: struct ifbreq *ifbr = (struct ifbreq *)data;
2137: struct bridge_iflist *p;
2138: struct ifnet *ifs;
2139: struct bstp_port *bp;
2140: int r = 0, err = 0, val;
2141:
2142: switch (cmd) {
2143: case SIOCBRDGSIFPRIO:
2144: case SIOCBRDGSIFCOST:
2145: ifs = ifunit(ifbr->ifbr_ifsname);
2146: if (ifs == NULL) {
2147: err = ENOENT;
2148: break;
2149: }
2150: if ((caddr_t)sc != ifs->if_bridge) {
2151: err = ESRCH;
2152: break;
2153: }
2154: LIST_FOREACH(p, &sc->sc_iflist, next) {
2155: if (p->ifp == ifs)
2156: break;
2157: }
2158: if (p == LIST_END(&sc->sc_iflist)) {
2159: err = ESRCH;
2160: break;
2161: }
2162: if ((p->bif_flags & IFBIF_STP) == 0) {
2163: err = EINVAL;
2164: break;
2165: }
2166: bp = p->bif_stp;
2167: break;
2168: default:
2169: break;
2170: }
2171: if (err)
2172: return (err);
2173:
2174: switch (cmd) {
2175: case SIOCBRDGGPRI:
2176: ifbp->ifbrp_prio = bs->bs_bridge_priority;
2177: break;
2178: case SIOCBRDGSPRI:
2179: val = ifbp->ifbrp_prio;
2180: if (val < 0 || val > BSTP_MAX_PRIORITY) {
2181: err = EINVAL;
2182: break;
2183: }
2184:
2185: /* Limit to steps of 4096 */
2186: val -= val % 4096;
2187: bs->bs_bridge_priority = val;
2188: r = 1;
2189: break;
2190: case SIOCBRDGGMA:
2191: ifbp->ifbrp_maxage = bs->bs_bridge_max_age >> 8;
2192: break;
2193: case SIOCBRDGSMA:
2194: val = ifbp->ifbrp_maxage;
2195:
2196: /* convert seconds to ticks */
2197: val *= BSTP_TICK_VAL;
2198:
2199: if (val < BSTP_MIN_MAX_AGE || val > BSTP_MAX_MAX_AGE) {
2200: err = EINVAL;
2201: break;
2202: }
2203: bs->bs_bridge_max_age = val;
2204: r = 1;
2205: break;
2206: case SIOCBRDGGHT:
2207: ifbp->ifbrp_hellotime = bs->bs_bridge_htime >> 8;
2208: break;
2209: case SIOCBRDGSHT:
2210: val = ifbp->ifbrp_hellotime;
2211:
2212: /* convert seconds to ticks */
2213: val *= BSTP_TICK_VAL;
2214:
2215: /* value can only be changed in leagacy stp mode */
2216: if (bs->bs_protover != BSTP_PROTO_STP) {
2217: err = EPERM;
2218: break;
2219: }
2220: if (val < BSTP_MIN_HELLO_TIME || val > BSTP_MAX_HELLO_TIME) {
2221: err = EINVAL;
2222: break;
2223: }
2224: bs->bs_bridge_htime = val;
2225: r = 1;
2226: break;
2227: case SIOCBRDGGFD:
2228: ifbp->ifbrp_fwddelay = bs->bs_bridge_fdelay >> 8;
2229: break;
2230: case SIOCBRDGSFD:
2231: val = ifbp->ifbrp_fwddelay;
2232:
2233: /* convert seconds to ticks */
2234: val *= BSTP_TICK_VAL;
2235:
2236: if (val < BSTP_MIN_FORWARD_DELAY ||
2237: val > BSTP_MAX_FORWARD_DELAY) {
2238: err = EINVAL;
2239: break;
2240: }
2241: bs->bs_bridge_fdelay = val;
2242: r = 1;
2243: break;
2244: case SIOCBRDGSTXHC:
2245: val = ifbp->ifbrp_txhc;
2246:
2247: if (val < BSTP_MIN_HOLD_COUNT || val > BSTP_MAX_HOLD_COUNT) {
2248: err = EINVAL;
2249: break;
2250: }
2251: bs->bs_txholdcount = val;
2252: LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
2253: bp->bp_txcount = 0;
2254: break;
2255: case SIOCBRDGSIFPRIO:
2256: val = ifbr->ifbr_priority;
2257: if (val < 0 || val > BSTP_MAX_PORT_PRIORITY)
2258: return (EINVAL);
2259:
2260: /* Limit to steps of 16 */
2261: val -= val % 16;
2262: bp->bp_priority = val;
2263: r = 1;
2264: break;
2265: case SIOCBRDGSIFCOST:
2266: val = ifbr->ifbr_path_cost;
2267: if (val > BSTP_MAX_PATH_COST) {
2268: err = EINVAL;
2269: break;
2270: }
2271: if (val == 0) { /* use auto */
2272: bp->bp_flags &= ~BSTP_PORT_ADMCOST;
2273: bp->bp_path_cost = bstp_calc_path_cost(bp);
2274: } else {
2275: bp->bp_path_cost = val;
2276: bp->bp_flags |= BSTP_PORT_ADMCOST;
2277: }
2278: r = 1;
2279: break;
2280: case SIOCBRDGSPROTO:
2281: val = ifbp->ifbrp_proto;
2282:
2283: /* Supported protocol versions */
2284: switch (val) {
2285: case BSTP_PROTO_STP:
2286: case BSTP_PROTO_RSTP:
2287: bs->bs_protover = val;
2288: bs->bs_bridge_htime = BSTP_DEFAULT_HELLO_TIME;
2289: LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
2290: /* reinit state */
2291: bp->bp_infois = BSTP_INFO_DISABLED;
2292: bp->bp_txcount = 0;
2293: bstp_set_port_proto(bp, bs->bs_protover);
2294: bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
2295: bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
2296: bstp_timer_stop(&bp->bp_recent_backup_timer);
2297: }
2298: r = 1;
2299: break;
2300: default:
2301: err = EINVAL;
2302: }
2303: break;
2304: default:
2305: break;
2306: }
2307:
2308: if (r)
2309: bstp_initialization(bs);
2310:
2311: return (err);
2312: }
2313: #endif /* NBRIDGE */