Make all network interrupt service routines MPSAFE part 1/3.
[dragonfly.git] / sys / net / vlan / if_vlan.c
1 /*
2  * Copyright 1998 Massachusetts Institute of Technology
3  *
4  * Permission to use, copy, modify, and distribute this software and
5  * its documentation for any purpose and without fee is hereby
6  * granted, provided that both the above copyright notice and this
7  * permission notice appear in all copies, that both the above
8  * copyright notice and this permission notice appear in all
9  * supporting documentation, and that the name of M.I.T. not be used
10  * in advertising or publicity pertaining to distribution of the
11  * software without specific, written prior permission.  M.I.T. makes
12  * no representations about the suitability of this software for any
13  * purpose.  It is provided "as is" without express or implied
14  * warranty.
15  * 
16  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
17  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
18  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
20  * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $FreeBSD: src/sys/net/if_vlan.c,v 1.15.2.13 2003/02/14 22:25:58 fenner Exp $
30  * $DragonFly: src/sys/net/vlan/if_vlan.c,v 1.18 2005/11/28 17:13:46 dillon Exp $
31  */
32
33 /*
34  * if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs.
35  * Might be extended some day to also handle IEEE 802.1p priority
36  * tagging.  This is sort of sneaky in the implementation, since
37  * we need to pretend to be enough of an Ethernet implementation
38  * to make arp work.  The way we do this is by telling everyone
39  * that we are an Ethernet, and then catch the packets that
40  * ether_output() left on our output queue queue when it calls
41  * if_start(), rewrite them for use by the real outgoing interface,
42  * and ask it to send them.
43  *
44  *
45  * XXX It's incorrect to assume that we must always kludge up
46  * headers on the physical device's behalf: some devices support
47  * VLAN tag insertion and extraction in firmware. For these cases,
48  * one can change the behavior of the vlan interface by setting
49  * the LINK0 flag on it (that is setting the vlan interface's LINK0
50  * flag, _not_ the parent's LINK0 flag; we try to leave the parent
51  * alone). If the interface has the LINK0 flag set, then it will
52  * not modify the ethernet header on output, because the parent
53  * can do that for itself. On input, the parent can call vlan_input_tag()
54  * directly in order to supply us with an incoming mbuf and the vlan
55  * tag value that goes with it.
56  */
57
58 #ifndef NVLAN
59 #include "use_vlan.h"
60 #endif
61 #include "opt_inet.h"
62
63 #include <sys/param.h>
64 #include <sys/kernel.h>
65 #include <sys/malloc.h>
66 #include <sys/mbuf.h>
67 #include <sys/module.h>
68 #include <sys/queue.h>
69 #include <sys/socket.h>
70 #include <sys/sockio.h>
71 #include <sys/sysctl.h>
72 #include <sys/systm.h>
73 #include <sys/thread2.h>
74 #include <machine/bus.h>        /* XXX: Shouldn't really be required! */
75
76 #include <net/bpf.h>
77 #include <net/ethernet.h>
78 #include <net/if.h>
79 #include <net/if_arp.h>
80 #include <net/if_dl.h>
81 #include <net/if_types.h>
82 #include <net/ifq_var.h>
83 #include "if_vlan_var.h"
84
85 #ifdef INET
86 #include <netinet/in.h>
87 #include <netinet/if_ether.h>
88 #endif
89
90 #define VLANNAME        "vlan"
91
92 SYSCTL_DECL(_net_link);
93 SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW, 0, "IEEE 802.1Q VLAN");
94 SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, "for consistency");
95
96 static MALLOC_DEFINE(M_VLAN, "vlan", "802.1Q Virtual LAN Interface");
97 static LIST_HEAD(, ifvlan) ifv_list;
98
99 static  int vlan_clone_create(struct if_clone *, int);
100 static  void vlan_clone_destroy(struct ifnet *);
101 static  void vlan_start(struct ifnet *ifp);
102 static  void vlan_ifinit(void *foo);
103 static  int vlan_input(struct ether_header *eh, struct mbuf *m);
104 static  int vlan_input_tag(struct mbuf *m, uint16_t t);
105 static  int vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr,
106                 struct ucred *cr);
107 static  int vlan_setmulti(struct ifnet *ifp);
108 static  int vlan_unconfig(struct ifnet *ifp);
109 static  int vlan_config(struct ifvlan *ifv, struct ifnet *p);
110
111 struct if_clone vlan_cloner = IF_CLONE_INITIALIZER("vlan", vlan_clone_create,
112     vlan_clone_destroy, NVLAN, IF_MAXUNIT);
113
114 /*
115  * Program our multicast filter. What we're actually doing is
116  * programming the multicast filter of the parent. This has the
117  * side effect of causing the parent interface to receive multicast
118  * traffic that it doesn't really want, which ends up being discarded
119  * later by the upper protocol layers. Unfortunately, there's no way
120  * to avoid this: there really is only one physical interface.
121  */
122 static int
123 vlan_setmulti(struct ifnet *ifp)
124 {
125         struct ifnet            *ifp_p;
126         struct ifmultiaddr      *ifma, *rifma = NULL;
127         struct ifvlan           *sc;
128         struct vlan_mc_entry    *mc = NULL;
129         struct sockaddr_dl      sdl;
130         int                     error;
131
132         /* Find the parent. */
133         sc = ifp->if_softc;
134         ifp_p = sc->ifv_p;
135
136         /*
137          * If we don't have a parent, just remember the membership for
138          * when we do.
139          */
140         if (ifp_p == NULL)
141                 return(0);
142
143         bzero((char *)&sdl, sizeof sdl);
144         sdl.sdl_len = sizeof sdl;
145         sdl.sdl_family = AF_LINK;
146         sdl.sdl_index = ifp_p->if_index;
147         sdl.sdl_type = IFT_ETHER;
148         sdl.sdl_alen = ETHER_ADDR_LEN;
149
150         /* First, remove any existing filter entries. */
151         while(SLIST_FIRST(&sc->vlan_mc_listhead) != NULL) {
152                 mc = SLIST_FIRST(&sc->vlan_mc_listhead);
153                 bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN);
154                 error = if_delmulti(ifp_p, (struct sockaddr *)&sdl);
155                 if (error)
156                         return(error);
157                 SLIST_REMOVE_HEAD(&sc->vlan_mc_listhead, mc_entries);
158                 free(mc, M_VLAN);
159         }
160
161         /* Now program new ones. */
162         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
163                 if (ifma->ifma_addr->sa_family != AF_LINK)
164                         continue;
165                 mc = malloc(sizeof(struct vlan_mc_entry), M_VLAN, M_WAITOK);
166                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
167                     (char *)&mc->mc_addr, ETHER_ADDR_LEN);
168                 SLIST_INSERT_HEAD(&sc->vlan_mc_listhead, mc, mc_entries);
169                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
170                     LLADDR(&sdl), ETHER_ADDR_LEN);
171                 error = if_addmulti(ifp_p, (struct sockaddr *)&sdl, &rifma);
172                 if (error)
173                         return(error);
174         }
175
176         return(0);
177 }
178
179 static int
180 vlan_modevent(module_t mod, int type, void *data) 
181
182
183         switch (type) { 
184         case MOD_LOAD: 
185                 LIST_INIT(&ifv_list);
186                 vlan_input_p = vlan_input;
187                 vlan_input_tag_p = vlan_input_tag;
188                 if_clone_attach(&vlan_cloner);
189                 break; 
190         case MOD_UNLOAD: 
191                 if_clone_detach(&vlan_cloner);
192                 vlan_input_p = NULL;
193                 vlan_input_tag_p = NULL;
194                 while (!LIST_EMPTY(&ifv_list))
195                         vlan_clone_destroy(&LIST_FIRST(&ifv_list)->ifv_if);
196                 break;
197         } 
198         return 0; 
199
200
201 static moduledata_t vlan_mod = { 
202         "if_vlan", 
203         vlan_modevent, 
204         0
205 }; 
206
207 DECLARE_MODULE(if_vlan, vlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
208
209 static int
210 vlan_clone_create(struct if_clone *ifc, int unit)
211 {
212         struct ifvlan *ifv;
213         struct ifnet *ifp;
214
215         ifv = malloc(sizeof(struct ifvlan), M_VLAN, M_WAITOK | M_ZERO);
216         ifp = &ifv->ifv_if;
217         SLIST_INIT(&ifv->vlan_mc_listhead);
218
219         crit_enter();
220         LIST_INSERT_HEAD(&ifv_list, ifv, ifv_list);
221         crit_exit();
222
223         ifp->if_softc = ifv;
224         if_initname(ifp, "vlan", unit);
225         /* NB: flags are not set here */
226         ifp->if_linkmib = &ifv->ifv_mib;
227         ifp->if_linkmiblen = sizeof ifv->ifv_mib;
228         /* NB: mtu is not set here */
229
230         ifp->if_init = vlan_ifinit;
231         ifp->if_start = vlan_start;
232         ifp->if_ioctl = vlan_ioctl;
233         ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
234         ifq_set_ready(&ifp->if_snd);
235         ether_ifattach(ifp, ifv->ifv_ac.ac_enaddr, NULL);
236         /* Now undo some of the damage... */
237         ifp->if_data.ifi_type = IFT_L2VLAN;
238         ifp->if_data.ifi_hdrlen = EVL_ENCAPLEN;
239
240         return (0);
241 }
242
243 static void
244 vlan_clone_destroy(struct ifnet *ifp)
245 {
246         struct ifvlan *ifv = ifp->if_softc;
247
248         crit_enter();
249
250         LIST_REMOVE(ifv, ifv_list);
251         vlan_unconfig(ifp);
252         ether_ifdetach(ifp);
253
254         crit_exit();
255
256         free(ifv, M_VLAN);
257 }
258
259 static void
260 vlan_ifinit(void *foo)
261 {
262         return;
263 }
264
265 static void
266 vlan_start(struct ifnet *ifp)
267 {
268         struct ifvlan *ifv;
269         struct ifnet *p;
270         struct ether_vlan_header *evl;
271         struct mbuf *m;
272         int error;
273         struct altq_pktattr pktattr;
274
275         ifv = ifp->if_softc;
276         p = ifv->ifv_p;
277
278         ifp->if_flags |= IFF_OACTIVE;
279         for (;;) {
280                 m = ifq_dequeue(&ifp->if_snd, NULL);
281                 if (m == NULL)
282                         break;
283                 BPF_MTAP(ifp, m);
284
285                 /*
286                  * Do not run parent's if_start() if the parent is not up,
287                  * or parent's driver will cause a system crash.
288                  */
289                 if ((p->if_flags & (IFF_UP | IFF_RUNNING)) !=
290                                         (IFF_UP | IFF_RUNNING)) {
291                         m_freem(m);
292                         ifp->if_data.ifi_collisions++;
293                         continue;
294                 }
295
296                 /*
297                  * If ALTQ is enabled on the parent interface, do
298                  * classification; the queueing discipline might
299                  * not require classification, but might require
300                  * the address family/header pointer in the pktattr.
301                  */
302                 if (ifq_is_enabled(&p->if_snd))
303                         altq_etherclassify(&p->if_snd, m, &pktattr);
304
305                 /*
306                  * If the LINK0 flag is set, it means the underlying interface
307                  * can do VLAN tag insertion itself and doesn't require us to
308                  * create a special header for it. In this case, we just pass
309                  * the packet along. However, we need some way to tell the
310                  * interface where the packet came from so that it knows how
311                  * to find the VLAN tag to use, so we set the rcvif in the
312                  * mbuf header to our ifnet.
313                  *
314                  * Note: we also set the M_PROTO1 flag in the mbuf to let
315                  * the parent driver know that the rcvif pointer is really
316                  * valid. We need to do this because sometimes mbufs will
317                  * be allocated by other parts of the system that contain
318                  * garbage in the rcvif pointer. Using the M_PROTO1 flag
319                  * lets the driver perform a proper sanity check and avoid
320                  * following potentially bogus rcvif pointers off into
321                  * never-never land.
322                  */
323                 if (ifp->if_flags & IFF_LINK0) {
324                         m->m_pkthdr.rcvif = ifp;
325                         m->m_flags |= M_PROTO1;
326                 } else {
327                         M_PREPEND(m, EVL_ENCAPLEN, MB_DONTWAIT);
328                         if (m == NULL) {
329                                 printf("%s: M_PREPEND failed", ifp->if_xname);
330                                 ifp->if_ierrors++;
331                                 continue;
332                         }
333                         /* M_PREPEND takes care of m_len, m_pkthdr.len for us */
334
335                         m = m_pullup(m, ETHER_HDR_LEN + EVL_ENCAPLEN);
336                         if (m == NULL) {
337                                 printf("%s: m_pullup failed", ifp->if_xname);
338                                 ifp->if_ierrors++;
339                                 continue;
340                         }
341
342                         /*
343                          * Transform the Ethernet header into an Ethernet header
344                          * with 802.1Q encapsulation.
345                          */
346                         bcopy(mtod(m, char *) + EVL_ENCAPLEN, mtod(m, char *),
347                               sizeof(struct ether_header));
348                         evl = mtod(m, struct ether_vlan_header *);
349                         evl->evl_proto = evl->evl_encap_proto;
350                         evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
351                         evl->evl_tag = htons(ifv->ifv_tag);
352 #ifdef DEBUG
353                         printf("vlan_start: %*D\n", sizeof *evl,
354                             (unsigned char *)evl, ":");
355 #endif
356                 }
357
358                 /*
359                  * Send it, precisely as ether_output() would have.
360                  * We are already running at splimp.
361                  */
362                 lwkt_serialize_exit(ifp->if_serializer);
363                 lwkt_serialize_enter(p->if_serializer);
364                 error = ifq_handoff(p, m, &pktattr);
365                 lwkt_serialize_exit(p->if_serializer);
366                 lwkt_serialize_enter(ifp->if_serializer);
367                 if (error)
368                         ifp->if_oerrors++;
369                 else
370                         ifp->if_opackets++;
371         }
372         ifp->if_flags &= ~IFF_OACTIVE;
373
374         return;
375 }
376
377 static int
378 vlan_input_tag( struct mbuf *m, uint16_t t)
379 {
380         struct bpf_if *bif;
381         struct ifvlan *ifv;
382         struct ether_header *eh = mtod(m, struct ether_header *);
383         struct ifnet *rcvif;
384
385         m_adj(m, ETHER_HDR_LEN);
386         rcvif = m->m_pkthdr.rcvif;
387
388         ASSERT_SERIALIZED(rcvif->if_serializer);
389
390         /*
391          * Fake up a header and send the packet to the physical interface's
392          * bpf tap if active.
393          */
394         if ((bif = rcvif->if_bpf) != NULL) {
395                 struct ether_vlan_header evh;
396
397                 bcopy(eh, &evh, 2*ETHER_ADDR_LEN);
398                 evh.evl_encap_proto = htons(ETHERTYPE_VLAN);
399                 evh.evl_tag = htons(t);
400                 evh.evl_proto = eh->ether_type;
401
402                 bpf_ptap(bif, m, &evh, ETHER_HDR_LEN + EVL_ENCAPLEN);
403         }
404
405         for (ifv = LIST_FIRST(&ifv_list); ifv != NULL;
406             ifv = LIST_NEXT(ifv, ifv_list)) {
407                 if (rcvif == ifv->ifv_p && ifv->ifv_tag == t)
408                         break;
409         }
410
411         if (ifv == NULL || (ifv->ifv_if.if_flags & IFF_UP) == 0) {
412                 m_freem(m);
413                 return -1;      /* So the parent can take note */
414         }
415
416         /*
417          * Having found a valid vlan interface corresponding to
418          * the given source interface and vlan tag, run the
419          * the real packet through ether_input().
420          */
421         m->m_pkthdr.rcvif = &ifv->ifv_if;
422
423         ifv->ifv_if.if_ipackets++;
424         lwkt_serialize_exit(rcvif->if_serializer);
425         lwkt_serialize_enter(ifv->ifv_if.if_serializer);
426         ether_input(&ifv->ifv_if, eh, m);
427         lwkt_serialize_exit(ifv->ifv_if.if_serializer);
428         lwkt_serialize_enter(rcvif->if_serializer);
429         return 0;
430 }
431
432 static int
433 vlan_input(struct ether_header *eh, struct mbuf *m)
434 {
435         struct ifvlan *ifv;
436         struct ifnet *rcvif;
437
438         rcvif = m->m_pkthdr.rcvif;
439         ASSERT_SERIALIZED(rcvif->if_serializer);
440
441         for (ifv = LIST_FIRST(&ifv_list); ifv != NULL;
442             ifv = LIST_NEXT(ifv, ifv_list)) {
443                 if (rcvif == ifv->ifv_p
444                     && (EVL_VLANOFTAG(ntohs(*mtod(m, u_int16_t *)))
445                         == ifv->ifv_tag))
446                         break;
447         }
448
449         if (ifv == NULL || (ifv->ifv_if.if_flags & IFF_UP) == 0) {
450                 rcvif->if_noproto++;
451                 m_freem(m);
452                 return -1;      /* so ether_input can take note */
453         }
454
455         /*
456          * Having found a valid vlan interface corresponding to
457          * the given source interface and vlan tag, remove the
458          * encapsulation, and run the real packet through
459          * ether_input() a second time (it had better be
460          * reentrant!).
461          */
462         m->m_pkthdr.rcvif = &ifv->ifv_if;
463         eh->ether_type = mtod(m, u_int16_t *)[1];
464         m->m_data += EVL_ENCAPLEN;
465         m->m_len -= EVL_ENCAPLEN;
466         m->m_pkthdr.len -= EVL_ENCAPLEN;
467
468         ifv->ifv_if.if_ipackets++;
469         lwkt_serialize_exit(rcvif->if_serializer);
470         lwkt_serialize_enter(ifv->ifv_if.if_serializer);
471         ether_input(&ifv->ifv_if, eh, m);
472         lwkt_serialize_exit(ifv->ifv_if.if_serializer);
473         lwkt_serialize_enter(rcvif->if_serializer);
474         return 0;
475 }
476
477 static int
478 vlan_config(struct ifvlan *ifv, struct ifnet *p)
479 {
480         struct sockaddr_dl *sdl1, *sdl2;
481
482         if (p->if_data.ifi_type != IFT_ETHER)
483                 return EPROTONOSUPPORT;
484         if (ifv->ifv_p)
485                 return EBUSY;
486         ifv->ifv_p = p;
487         if (p->if_data.ifi_hdrlen == sizeof(struct ether_vlan_header))
488                 ifv->ifv_if.if_mtu = p->if_mtu;
489         else
490                 ifv->ifv_if.if_mtu = p->if_data.ifi_mtu - EVL_ENCAPLEN;
491
492         /*
493          * Copy only a selected subset of flags from the parent.
494          * Other flags are none of our business.
495          */
496         ifv->ifv_if.if_flags = (p->if_flags &
497             (IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX | IFF_POINTOPOINT));
498
499         /*
500          * Set up our ``Ethernet address'' to reflect the underlying
501          * physical interface's.
502          */
503         sdl1 = IF_LLSOCKADDR(&ifv->ifv_if);
504         sdl2 = IF_LLSOCKADDR(p);
505         sdl1->sdl_type = IFT_ETHER;
506         sdl1->sdl_alen = ETHER_ADDR_LEN;
507         bcopy(LLADDR(sdl2), LLADDR(sdl1), ETHER_ADDR_LEN);
508         bcopy(LLADDR(sdl2), ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
509
510         /*
511          * Configure multicast addresses that may already be
512          * joined on the vlan device.
513          */
514         (void)vlan_setmulti(&ifv->ifv_if);
515
516         return 0;
517 }
518
519 static int
520 vlan_unconfig(struct ifnet *ifp)
521 {
522         struct sockaddr_dl *sdl;
523         struct vlan_mc_entry *mc;
524         struct ifvlan *ifv;
525         struct ifnet *p;
526         int error;
527
528         ifv = ifp->if_softc;
529         p = ifv->ifv_p;
530
531         if (p) {
532                 struct sockaddr_dl sdl;
533
534                 /*
535                  * Since the interface is being unconfigured, we need to
536                  * empty the list of multicast groups that we may have joined
537                  * while we were alive from the parent's list.
538                  */
539                 bzero((char *)&sdl, sizeof sdl);
540                 sdl.sdl_len = sizeof sdl;
541                 sdl.sdl_family = AF_LINK;
542                 sdl.sdl_index = p->if_index;
543                 sdl.sdl_type = IFT_ETHER;
544                 sdl.sdl_alen = ETHER_ADDR_LEN;
545
546                 while(SLIST_FIRST(&ifv->vlan_mc_listhead) != NULL) {
547                         mc = SLIST_FIRST(&ifv->vlan_mc_listhead);
548                         bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN);
549                         error = if_delmulti(p, (struct sockaddr *)&sdl);
550                         if (error)
551                                 return(error);
552                         SLIST_REMOVE_HEAD(&ifv->vlan_mc_listhead, mc_entries);
553                         free(mc, M_VLAN);
554                 }
555         }
556
557         /* Disconnect from parent. */
558         ifv->ifv_p = NULL;
559         ifv->ifv_if.if_mtu = ETHERMTU;
560
561         /* Clear our MAC address. */
562         sdl = IF_LLSOCKADDR(&ifv->ifv_if);
563         sdl->sdl_type = IFT_ETHER;
564         sdl->sdl_alen = ETHER_ADDR_LEN;
565         bzero(LLADDR(sdl), ETHER_ADDR_LEN);
566         bzero(ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
567
568         return 0;
569 }
570
571 static int
572 vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
573 {
574         struct ifaddr *ifa;
575         struct ifnet *p;
576         struct ifreq *ifr;
577         struct ifvlan *ifv;
578         struct vlanreq vlr;
579         int error = 0;
580
581         ifr = (struct ifreq *)data;
582         ifa = (struct ifaddr *)data;
583         ifv = ifp->if_softc;
584
585         ASSERT_SERIALIZED(ifp->if_serializer);
586         crit_enter();
587
588         switch (cmd) {
589         case SIOCSIFADDR:
590                 ifp->if_flags |= IFF_UP;
591
592                 switch (ifa->ifa_addr->sa_family) {
593 #ifdef INET
594                 case AF_INET:
595                         arp_ifinit(&ifv->ifv_if, ifa);
596                         break;
597 #endif
598                 default:
599                         break;
600                 }
601                 break;
602
603         case SIOCGIFADDR:
604                 {
605                         struct sockaddr *sa;
606
607                         sa = (struct sockaddr *) &ifr->ifr_data;
608                         bcopy(((struct arpcom *)ifp->if_softc)->ac_enaddr,
609                               (caddr_t) sa->sa_data, ETHER_ADDR_LEN);
610                 }
611                 break;
612
613         case SIOCGIFMEDIA:
614                 if (ifv->ifv_p != NULL) {
615                         lwkt_serialize_exit(ifp->if_serializer);
616                         lwkt_serialize_enter(ifv->ifv_p->if_serializer);
617                         error = ifv->ifv_p->if_ioctl(ifv->ifv_p,
618                                                      SIOCGIFMEDIA, data, cr);
619                         lwkt_serialize_exit(ifv->ifv_p->if_serializer);
620                         lwkt_serialize_enter(ifp->if_serializer);
621                         /* Limit the result to the parent's current config. */
622                         if (error == 0) {
623                                 struct ifmediareq *ifmr;
624
625                                 ifmr = (struct ifmediareq *) data;
626                                 if (ifmr->ifm_count >= 1 && ifmr->ifm_ulist) {
627                                         ifmr->ifm_count = 1;
628                                         error = copyout(&ifmr->ifm_current,
629                                                 ifmr->ifm_ulist, 
630                                                 sizeof(int));
631                                 }
632                         }
633                 } else
634                         error = EINVAL;
635                 break;
636
637         case SIOCSIFMEDIA:
638                 error = EINVAL;
639                 break;
640
641         case SIOCSIFMTU:
642                 /*
643                  * Set the interface MTU.
644                  * This is bogus. The underlying interface might support
645                  * jumbo frames.
646                  */
647                 if (ifr->ifr_mtu > ETHERMTU) {
648                         error = EINVAL;
649                 } else {
650                         ifp->if_mtu = ifr->ifr_mtu;
651                 }
652                 break;
653
654         case SIOCSETVLAN:
655                 error = copyin(ifr->ifr_data, &vlr, sizeof vlr);
656                 if (error)
657                         break;
658                 if (vlr.vlr_parent[0] == '\0') {
659                         vlan_unconfig(ifp);
660                         if (ifp->if_flags & IFF_UP)
661                                 if_down(ifp);
662                         ifp->if_flags &= ~IFF_RUNNING;
663                         break;
664                 }
665                 p = ifunit(vlr.vlr_parent);
666                 if (p == 0) {
667                         error = ENOENT;
668                         break;
669                 }
670                 error = vlan_config(ifv, p);
671                 if (error)
672                         break;
673                 ifv->ifv_tag = vlr.vlr_tag;
674                 ifp->if_flags |= IFF_RUNNING;
675                 break;
676                 
677         case SIOCGETVLAN:
678                 bzero(&vlr, sizeof vlr);
679                 if (ifv->ifv_p) {
680                         strlcpy(vlr.vlr_parent, ifv->ifv_p->if_xname,
681                             sizeof(vlr.vlr_parent));
682                         vlr.vlr_tag = ifv->ifv_tag;
683                 }
684                 error = copyout(&vlr, ifr->ifr_data, sizeof vlr);
685                 break;
686                 
687         case SIOCSIFFLAGS:
688                 /*
689                  * We don't support promiscuous mode
690                  * right now because it would require help from the
691                  * underlying drivers, which hasn't been implemented.
692                  */
693                 if (ifr->ifr_flags & (IFF_PROMISC)) {
694                         ifp->if_flags &= ~(IFF_PROMISC);
695                         error = EINVAL;
696                 }
697                 break;
698         case SIOCADDMULTI:
699         case SIOCDELMULTI:
700                 error = vlan_setmulti(ifp);
701                 break;
702         default:
703                 error = EINVAL;
704         }
705
706         crit_exit();
707
708         return error;
709 }