![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vlan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to vlan.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 root 1: /*
2: * Copyright (C) 2010 Michael Brown <[email protected]>.
3: *
4: * This program is free software; you can redistribute it and/or
5: * modify it under the terms of the GNU General Public License as
6: * published by the Free Software Foundation; either version 2 of the
7: * License, or any later version.
8: *
9: * This program is distributed in the hope that it will be useful, but
10: * WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: * General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: #include <stdint.h>
22: #include <string.h>
23: #include <stdio.h>
24: #include <errno.h>
25: #include <byteswap.h>
26: #include <ipxe/features.h>
27: #include <ipxe/if_ether.h>
28: #include <ipxe/ethernet.h>
29: #include <ipxe/netdevice.h>
30: #include <ipxe/iobuf.h>
31: #include <ipxe/vlan.h>
32:
33: /** @file
34: *
35: * Virtual LANs
36: *
37: */
38:
39: FEATURE ( FEATURE_PROTOCOL, "VLAN", DHCP_EB_FEATURE_VLAN, 1 );
40:
41: struct net_protocol vlan_protocol __net_protocol;
42:
43: /** VLAN device private data */
44: struct vlan_device {
45: /** Trunk network device */
46: struct net_device *trunk;
47: /** VLAN tag */
48: unsigned int tag;
49: /** Default priority */
50: unsigned int priority;
51: };
52:
53: /**
54: * Open VLAN device
55: *
56: * @v netdev Network device
57: * @ret rc Return status code
58: */
59: static int vlan_open ( struct net_device *netdev ) {
60: struct vlan_device *vlan = netdev->priv;
61:
62: return netdev_open ( vlan->trunk );
63: }
64:
65: /**
66: * Close VLAN device
67: *
68: * @v netdev Network device
69: */
70: static void vlan_close ( struct net_device *netdev ) {
71: struct vlan_device *vlan = netdev->priv;
72:
73: netdev_close ( vlan->trunk );
74: }
75:
76: /**
77: * Transmit packet on VLAN device
78: *
79: * @v netdev Network device
80: * @v iobuf I/O buffer
81: * @ret rc Return status code
82: */
83: static int vlan_transmit ( struct net_device *netdev,
84: struct io_buffer *iobuf ) {
85: struct vlan_device *vlan = netdev->priv;
86: struct net_device *trunk = vlan->trunk;
87: struct ll_protocol *ll_protocol;
88: struct vlan_header *vlanhdr;
89: uint8_t ll_dest_copy[ETH_ALEN];
90: uint8_t ll_source_copy[ETH_ALEN];
91: const void *ll_dest;
92: const void *ll_source;
93: uint16_t net_proto;
94: int rc;
95:
96: /* Strip link-layer header and preserve link-layer header fields */
97: ll_protocol = netdev->ll_protocol;
98: if ( ( rc = ll_protocol->pull ( netdev, iobuf, &ll_dest, &ll_source,
99: &net_proto ) ) != 0 ) {
100: DBGC ( netdev, "VLAN %s could not parse link-layer header: "
101: "%s\n", netdev->name, strerror ( rc ) );
102: return rc;
103: }
104: memcpy ( ll_dest_copy, ll_dest, ETH_ALEN );
105: memcpy ( ll_source_copy, ll_source, ETH_ALEN );
106:
107: /* Construct VLAN header */
108: vlanhdr = iob_push ( iobuf, sizeof ( *vlanhdr ) );
109: vlanhdr->tci = htons ( VLAN_TCI ( vlan->tag, vlan->priority ) );
110: vlanhdr->net_proto = net_proto;
111:
112: /* Reclaim I/O buffer from VLAN device's TX queue */
113: list_del ( &iobuf->list );
114:
115: /* Transmit packet on trunk device */
116: if ( ( rc = net_tx ( iob_disown ( iobuf ), trunk, &vlan_protocol,
117: ll_dest_copy, ll_source_copy ) ) != 0 ) {
118: DBGC ( netdev, "VLAN %s could not transmit: %s\n",
119: netdev->name, strerror ( rc ) );
120: /* Cannot return an error status, since that would
121: * cause the I/O buffer to be double-freed.
122: */
123: return 0;
124: }
125:
126: return 0;
127: }
128:
129: /**
130: * Poll VLAN device
131: *
132: * @v netdev Network device
133: */
134: static void vlan_poll ( struct net_device *netdev ) {
135: struct vlan_device *vlan = netdev->priv;
136:
137: /* Poll trunk device */
138: netdev_poll ( vlan->trunk );
139: }
140:
141: /**
142: * Enable/disable interrupts on VLAN device
143: *
144: * @v netdev Network device
145: * @v enable Interrupts should be enabled
146: */
147: static void vlan_irq ( struct net_device *netdev, int enable ) {
148: struct vlan_device *vlan = netdev->priv;
149:
150: /* Enable/disable interrupts on trunk device. This is not at
151: * all robust, but there is no sensible course of action
152: * available.
153: */
154: netdev_irq ( vlan->trunk, enable );
155: }
156:
157: /** VLAN device operations */
158: static struct net_device_operations vlan_operations = {
159: .open = vlan_open,
160: .close = vlan_close,
161: .transmit = vlan_transmit,
162: .poll = vlan_poll,
163: .irq = vlan_irq,
164: };
165:
166: /**
167: * Synchronise VLAN device
168: *
169: * @v netdev Network device
170: */
171: static void vlan_sync ( struct net_device *netdev ) {
172: struct vlan_device *vlan = netdev->priv;
173: struct net_device *trunk = vlan->trunk;
174:
175: /* Synchronise link status */
176: if ( netdev->link_rc != trunk->link_rc )
177: netdev_link_err ( netdev, trunk->link_rc );
178:
179: /* Synchronise open/closed status */
180: if ( netdev_is_open ( trunk ) ) {
181: if ( ! netdev_is_open ( netdev ) )
182: netdev_open ( netdev );
183: } else {
184: if ( netdev_is_open ( netdev ) )
185: netdev_close ( netdev );
186: }
187: }
188:
189: /**
190: * Identify VLAN device
191: *
192: * @v trunk Trunk network device
193: * @v tag VLAN tag
194: * @ret netdev VLAN device, if any
195: */
196: struct net_device * vlan_find ( struct net_device *trunk, unsigned int tag ) {
197: struct net_device *netdev;
198: struct vlan_device *vlan;
199:
200: for_each_netdev ( netdev ) {
201: if ( netdev->op != &vlan_operations )
202: continue;
203: vlan = netdev->priv;
204: if ( ( vlan->trunk == trunk ) && ( vlan->tag == tag ) )
205: return netdev;
206: }
207: return NULL;
208: }
209:
210: /**
211: * Process incoming VLAN packet
212: *
213: * @v iobuf I/O buffer
214: * @v trunk Trunk network device
215: * @v ll_dest Link-layer destination address
216: * @v ll_source Link-layer source address
217: * @ret rc Return status code
218: */
219: static int vlan_rx ( struct io_buffer *iobuf, struct net_device *trunk,
220: const void *ll_dest, const void *ll_source ) {
221: struct vlan_header *vlanhdr = iobuf->data;
222: struct net_device *netdev;
223: struct ll_protocol *ll_protocol;
224: uint8_t ll_dest_copy[ETH_ALEN];
225: uint8_t ll_source_copy[ETH_ALEN];
226: uint16_t tag;
227: int rc;
228:
229: /* Sanity check */
230: if ( iob_len ( iobuf ) < sizeof ( *vlanhdr ) ) {
231: DBGC ( trunk, "VLAN %s received underlength packet (%zd "
232: "bytes)\n", trunk->name, iob_len ( iobuf ) );
233: rc = -EINVAL;
234: goto err_sanity;
235: }
236:
237: /* Identify VLAN device */
238: tag = VLAN_TAG ( ntohs ( vlanhdr->tci ) );
239: netdev = vlan_find ( trunk, tag );
240: if ( ! netdev ) {
241: DBGC2 ( trunk, "VLAN %s received packet for unknown VLAN "
242: "%d\n", trunk->name, tag );
243: rc = -EPIPE;
244: goto err_no_vlan;
245: }
246:
247: /* Strip VLAN header and preserve original link-layer header fields */
248: iob_pull ( iobuf, sizeof ( *vlanhdr ) );
249: ll_protocol = trunk->ll_protocol;
250: memcpy ( ll_dest_copy, ll_dest, ETH_ALEN );
251: memcpy ( ll_source_copy, ll_source, ETH_ALEN );
252:
253: /* Reconstruct link-layer header for VLAN device */
254: ll_protocol = netdev->ll_protocol;
255: if ( ( rc = ll_protocol->push ( netdev, iobuf, ll_dest_copy,
256: ll_source_copy,
257: vlanhdr->net_proto ) ) != 0 ) {
258: DBGC ( netdev, "VLAN %s could not reconstruct link-layer "
259: "header: %s\n", netdev->name, strerror ( rc ) );
260: goto err_ll_push;
261: }
262:
263: /* Enqueue packet on VLAN device */
264: netdev_rx ( netdev, iob_disown ( iobuf ) );
265: return 0;
266:
267: err_ll_push:
268: err_no_vlan:
269: err_sanity:
270: free_iob ( iobuf );
271: return rc;
272: }
273:
274: /** VLAN protocol */
275: struct net_protocol vlan_protocol __net_protocol = {
276: .name = "VLAN",
277: .net_proto = htons ( ETH_P_8021Q ),
278: .rx = vlan_rx,
279: };
280:
281: /**
282: * Check if network device can be used as a VLAN trunk device
283: *
284: * @v trunk Trunk network device
285: * @ret is_ok Trunk network device is usable
286: *
287: * VLAN devices will be created as Ethernet devices. (We cannot
288: * simply clone the link layer of the trunk network device, because
289: * this link layer may expect the network device structure to contain
290: * some link-layer-private data.) The trunk network device must
291: * therefore have a link layer that is in some sense 'compatible' with
292: * Ethernet; specifically, it must have link-layer addresses that are
293: * the same length as Ethernet link-layer addresses.
294: *
295: * As an additional check, and primarily to assist with the sanity of
296: * the FCoE code, we refuse to allow nested VLANs.
297: */
298: int vlan_can_be_trunk ( struct net_device *trunk ) {
299:
300: return ( ( trunk->ll_protocol->ll_addr_len == ETH_ALEN ) &&
301: ( trunk->op != &vlan_operations ) );
302: }
303:
304: /**
305: * Create VLAN device
306: *
307: * @v trunk Trunk network device
308: * @v tag VLAN tag
309: * @v priority Default VLAN priority
310: * @ret rc Return status code
311: */
312: int vlan_create ( struct net_device *trunk, unsigned int tag,
313: unsigned int priority ) {
314: struct net_device *netdev;
315: struct vlan_device *vlan;
316: int rc;
317:
318: /* If VLAN already exists, just update the priority */
319: if ( ( netdev = vlan_find ( trunk, tag ) ) != NULL ) {
320: vlan = netdev->priv;
321: if ( priority != vlan->priority ) {
322: DBGC ( netdev, "VLAN %s priority changed from %d to "
323: "%d\n", netdev->name, vlan->priority, priority );
324: }
325: vlan->priority = priority;
326: return 0;
327: }
328:
329: /* Sanity checks */
330: if ( ! vlan_can_be_trunk ( trunk ) ) {
331: DBGC ( trunk, "VLAN %s cannot create VLAN on non-trunk "
332: "device\n", trunk->name );
333: rc = -ENOTTY;
334: goto err_sanity;
335: }
336: if ( ! VLAN_TAG_IS_VALID ( tag ) ) {
337: DBGC ( trunk, "VLAN %s cannot create VLAN with invalid tag "
338: "%d\n", trunk->name, tag );
339: rc = -EINVAL;
340: goto err_sanity;
341: }
342: if ( ! VLAN_PRIORITY_IS_VALID ( priority ) ) {
343: DBGC ( trunk, "VLAN %s cannot create VLAN with invalid "
344: "priority %d\n", trunk->name, priority );
345: rc = -EINVAL;
346: goto err_sanity;
347: }
348:
349: /* Allocate and initialise structure */
350: netdev = alloc_etherdev ( sizeof ( *vlan ) );
351: if ( ! netdev ) {
352: rc = -ENOMEM;
353: goto err_alloc_etherdev;
354: }
355: netdev_init ( netdev, &vlan_operations );
356: netdev->dev = trunk->dev;
357: memcpy ( netdev->hw_addr, trunk->ll_addr, ETH_ALEN );
358: vlan = netdev->priv;
359: vlan->trunk = netdev_get ( trunk );
360: vlan->tag = tag;
361: vlan->priority = priority;
362:
363: /* Construct VLAN device name */
364: snprintf ( netdev->name, sizeof ( netdev->name ), "%s-%d",
365: trunk->name, vlan->tag );
366:
367: /* Register VLAN device */
368: if ( ( rc = register_netdev ( netdev ) ) != 0 ) {
369: DBGC ( netdev, "VLAN %s could not register: %s\n",
370: netdev->name, strerror ( rc ) );
371: goto err_register;
372: }
373:
374: /* Synchronise with trunk device */
375: vlan_sync ( netdev );
376:
377: DBGC ( netdev, "VLAN %s created with tag %d and priority %d\n",
378: netdev->name, vlan->tag, vlan->priority );
379:
380: return 0;
381:
382: unregister_netdev ( netdev );
383: err_register:
384: netdev_nullify ( netdev );
385: netdev_put ( netdev );
386: netdev_put ( trunk );
387: err_alloc_etherdev:
388: err_sanity:
389: return rc;
390: }
391:
392: /**
393: * Destroy VLAN device
394: *
395: * @v netdev Network device
396: * @ret rc Return status code
397: */
398: int vlan_destroy ( struct net_device *netdev ) {
399: struct vlan_device *vlan = netdev->priv;
400: struct net_device *trunk;
401:
402: /* Sanity check */
403: if ( netdev->op != &vlan_operations ) {
404: DBGC ( netdev, "VLAN %s cannot destroy non-VLAN device\n",
405: netdev->name );
406: return -ENOTTY;
407: }
408:
409: DBGC ( netdev, "VLAN %s destroyed\n", netdev->name );
410:
411: /* Remove VLAN device */
412: unregister_netdev ( netdev );
413: trunk = vlan->trunk;
414: netdev_nullify ( netdev );
415: netdev_put ( netdev );
416: netdev_put ( trunk );
417:
418: return 0;
419: }
420:
421: /**
422: * Do nothing
423: *
424: * @v trunk Trunk network device
425: * @ret rc Return status code
426: */
427: static int vlan_probe ( struct net_device *trunk __unused ) {
428: return 0;
429: }
430:
431: /**
432: * Handle trunk network device link state change
433: *
434: * @v trunk Trunk network device
435: */
436: static void vlan_notify ( struct net_device *trunk ) {
437: struct net_device *netdev;
438: struct vlan_device *vlan;
439:
440: for_each_netdev ( netdev ) {
441: if ( netdev->op != &vlan_operations )
442: continue;
443: vlan = netdev->priv;
444: if ( vlan->trunk == trunk )
445: vlan_sync ( netdev );
446: }
447: }
448:
449: /**
450: * Destroy first VLAN device for a given trunk
451: *
452: * @v trunk Trunk network device
453: * @ret found A VLAN device was found
454: */
455: static int vlan_remove_first ( struct net_device *trunk ) {
456: struct net_device *netdev;
457: struct vlan_device *vlan;
458:
459: for_each_netdev ( netdev ) {
460: if ( netdev->op != &vlan_operations )
461: continue;
462: vlan = netdev->priv;
463: if ( vlan->trunk == trunk ) {
464: vlan_destroy ( netdev );
465: return 1;
466: }
467: }
468: return 0;
469: }
470:
471: /**
472: * Destroy all VLAN devices for a given trunk
473: *
474: * @v trunk Trunk network device
475: */
476: static void vlan_remove ( struct net_device *trunk ) {
477:
478: /* Remove all VLAN devices attached to this trunk, safe
479: * against arbitrary net device removal.
480: */
481: while ( vlan_remove_first ( trunk ) ) {}
482: }
483:
484: /** VLAN driver */
485: struct net_driver vlan_driver __net_driver = {
486: .name = "VLAN",
487: .probe = vlan_probe,
488: .notify = vlan_notify,
489: .remove = vlan_remove,
490: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.