if_media.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: if_media.c,v 1.1 1997/03/17 02:55:15 thorpej Exp $     */
    2 
    3 /*-
    4  * SPDX-License-Identifier: BSD-4-Clause
    5  *
    6  * Copyright (c) 1997
    7  *      Jonathan Stone and Jason R. Thorpe.  All rights reserved.
    8  *
    9  * This software is derived from information provided by Matt Thomas.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by Jonathan Stone
   22  *      and Jason R. Thorpe for the NetBSD Project.
   23  * 4. The names of the authors may not be used to endorse or promote products
   24  *    derived from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
   27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   31  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   32  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   33  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   34  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  */
   38 
   39 /*
   40  * BSD/OS-compatible network interface media selection.
   41  *
   42  * Where it is safe to do so, this code strays slightly from the BSD/OS
   43  * design.  Software which uses the API (device drivers, basically)
   44  * shouldn't notice any difference.
   45  *
   46  * Many thanks to Matt Thomas for providing the information necessary
   47  * to implement this interface.
   48  */
   49 
   50 #include <sys/cdefs.h>
   51 __FBSDID("$FreeBSD$");
   52 
   53 #include "opt_ifmedia.h"
   54 
   55 #include <sys/param.h>
   56 #include <sys/systm.h>
   57 #include <sys/socket.h>
   58 #include <sys/sockio.h>
   59 #include <sys/malloc.h>
   60 #include <sys/module.h>
   61 #include <sys/sysctl.h>
   62 
   63 #include <net/if.h>
   64 #include <net/if_media.h>
   65 
   66 /*
   67  * Compile-time options:
   68  * IFMEDIA_DEBUG:
   69  *      turn on implementation-level debug printfs.
   70  *      Useful for debugging newly-ported  drivers.
   71  */
   72 
   73 static struct ifmedia_entry *ifmedia_match(struct ifmedia *ifm,
   74     int flags, int mask);
   75 
   76 #ifdef IFMEDIA_DEBUG
   77 #include <net/if_var.h>
   78 int     ifmedia_debug = 0;
   79 SYSCTL_INT(_debug, OID_AUTO, ifmedia, CTLFLAG_RW, &ifmedia_debug,
   80             0, "if_media debugging msgs");
   81 static  void ifmedia_printword(int);
   82 #endif
   83 
   84 /*
   85  * Initialize if_media struct for a specific interface instance.
   86  */
   87 void
   88 ifmedia_init(struct ifmedia *ifm, int dontcare_mask,
   89     ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback)
   90 {
   91 
   92         LIST_INIT(&ifm->ifm_list);
   93         ifm->ifm_cur = NULL;
   94         ifm->ifm_media = 0;
   95         ifm->ifm_mask = dontcare_mask;          /* IF don't-care bits */
   96         ifm->ifm_change = change_callback;
   97         ifm->ifm_status = status_callback;
   98 }
   99 
  100 void
  101 ifmedia_removeall(struct ifmedia *ifm)
  102 {
  103         struct ifmedia_entry *entry;
  104 
  105         while ((entry = LIST_FIRST(&ifm->ifm_list)) != NULL) {
  106                 LIST_REMOVE(entry, ifm_list);
  107                 free(entry, M_IFADDR);
  108         }
  109         ifm->ifm_cur = NULL;
  110 }
  111 
  112 /*
  113  * Add a media configuration to the list of supported media
  114  * for a specific interface instance.
  115  */
  116 void
  117 ifmedia_add(struct ifmedia *ifm, int mword, int data, void *aux)
  118 {
  119         struct ifmedia_entry *entry;
  120 
  121 #ifdef IFMEDIA_DEBUG
  122         if (ifmedia_debug) {
  123                 if (ifm == NULL) {
  124                         printf("ifmedia_add: null ifm\n");
  125                         return;
  126                 }
  127                 printf("Adding entry for (%#010x) ", mword);
  128                 ifmedia_printword(mword);
  129         }
  130 #endif
  131 
  132         entry = malloc(sizeof(*entry), M_IFADDR, M_NOWAIT);
  133         if (entry == NULL)
  134                 panic("ifmedia_add: can't malloc entry");
  135 
  136         entry->ifm_media = mword;
  137         entry->ifm_data = data;
  138         entry->ifm_aux = aux;
  139 
  140         LIST_INSERT_HEAD(&ifm->ifm_list, entry, ifm_list);
  141 }
  142 
  143 /*
  144  * Add an array of media configurations to the list of
  145  * supported media for a specific interface instance.
  146  */
  147 void
  148 ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, int count)
  149 {
  150         int i;
  151 
  152         for (i = 0; i < count; i++)
  153                 ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data,
  154                     lp[i].ifm_aux);
  155 }
  156 
  157 /*
  158  * Set the default active media. 
  159  *
  160  * Called by device-specific code which is assumed to have already
  161  * selected the default media in hardware.  We do _not_ call the
  162  * media-change callback.
  163  */
  164 void
  165 ifmedia_set(struct ifmedia *ifm, int target)
  166 {
  167         struct ifmedia_entry *match;
  168 
  169         match = ifmedia_match(ifm, target, ifm->ifm_mask);
  170 
  171         if (match == NULL) {
  172                 printf("ifmedia_set: no match for 0x%x/0x%x\n",
  173                     target, ~ifm->ifm_mask);
  174                 panic("ifmedia_set");
  175         }
  176         ifm->ifm_cur = match;
  177 
  178 #ifdef IFMEDIA_DEBUG
  179         if (ifmedia_debug) {
  180                 printf("ifmedia_set: target ");
  181                 ifmedia_printword(target);
  182                 printf("ifmedia_set: setting to ");
  183                 ifmedia_printword(ifm->ifm_cur->ifm_media);
  184         }
  185 #endif
  186 }
  187 
  188 /*
  189  * Given a media word, return one suitable for an application
  190  * using the original encoding.
  191  */
  192 static int
  193 compat_media(int media)
  194 {
  195 
  196         if (IFM_TYPE(media) == IFM_ETHER && IFM_SUBTYPE(media) > IFM_OTHER) {
  197                 media &= ~(IFM_ETH_XTYPE|IFM_TMASK);
  198                 media |= IFM_OTHER;
  199         }
  200         return (media);
  201 }
  202 
  203 /*
  204  * Device-independent media ioctl support function.
  205  */
  206 int
  207 ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm,
  208     u_long cmd)
  209 {
  210         struct ifmedia_entry *match;
  211         struct ifmediareq *ifmr = (struct ifmediareq *) ifr;
  212         int error = 0;
  213 
  214         if (ifp == NULL || ifr == NULL || ifm == NULL)
  215                 return (EINVAL);
  216 
  217         switch (cmd) {
  218 
  219         /*
  220          * Set the current media.
  221          */
  222         case  SIOCSIFMEDIA:
  223         {
  224                 struct ifmedia_entry *oldentry;
  225                 int oldmedia;
  226                 int newmedia = ifr->ifr_media;
  227 
  228                 match = ifmedia_match(ifm, newmedia, ifm->ifm_mask);
  229                 if (match == NULL) {
  230 #ifdef IFMEDIA_DEBUG
  231                         if (ifmedia_debug) {
  232                                 printf(
  233                     "ifmedia_ioctl: no media found for %#010x mask %#010x\n", 
  234                                     newmedia, ifm->ifm_mask);
  235                         }
  236 #endif
  237                         return (ENXIO);
  238                 }
  239 
  240                 /*
  241                  * If no change, we're done.
  242                  * XXX Automedia may invole software intervention.
  243                  *     Keep going in case the connected media changed.
  244                  *     Similarly, if best match changed (kernel debugger?).
  245                  */
  246                 if (IFM_SUBTYPE(newmedia) != IFM_AUTO &&
  247                     newmedia == ifm->ifm_media && match == ifm->ifm_cur)
  248                         return (0);
  249 
  250                 /*
  251                  * We found a match, now make the driver switch to it.
  252                  * Make sure to preserve our old media type in case the
  253                  * driver can't switch.
  254                  */
  255 #ifdef IFMEDIA_DEBUG
  256                 if (ifmedia_debug) {
  257                         printf("ifmedia_ioctl: switching %s to ",
  258                             ifp->if_xname);
  259                         ifmedia_printword(match->ifm_media);
  260                 }
  261 #endif
  262                 oldentry = ifm->ifm_cur;
  263                 oldmedia = ifm->ifm_media;
  264                 ifm->ifm_cur = match;
  265                 ifm->ifm_media = newmedia;
  266                 error = (*ifm->ifm_change)(ifp);
  267                 if (error) {
  268                         ifm->ifm_cur = oldentry;
  269                         ifm->ifm_media = oldmedia;
  270                 }
  271                 break;
  272         }
  273 
  274         /*
  275          * Get list of available media and current media on interface.
  276          */
  277         case  SIOCGIFMEDIA: 
  278         case  SIOCGIFXMEDIA: 
  279         {
  280                 struct ifmedia_entry *ep;
  281                 int i;
  282 
  283                 if (ifmr->ifm_count < 0)
  284                         return (EINVAL);
  285 
  286                 if (cmd == SIOCGIFMEDIA) {
  287                         ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
  288                             compat_media(ifm->ifm_cur->ifm_media) : IFM_NONE;
  289                 } else {
  290                         ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
  291                             ifm->ifm_cur->ifm_media : IFM_NONE;
  292                 }
  293                 ifmr->ifm_mask = ifm->ifm_mask;
  294                 ifmr->ifm_status = 0;
  295                 (*ifm->ifm_status)(ifp, ifmr);
  296 
  297                 /*
  298                  * If there are more interfaces on the list, count
  299                  * them.  This allows the caller to set ifmr->ifm_count
  300                  * to 0 on the first call to know how much space to
  301                  * allocate.
  302                  */
  303                 i = 0;
  304                 LIST_FOREACH(ep, &ifm->ifm_list, ifm_list) {
  305                         if (i < ifmr->ifm_count) {
  306                                 error = copyout(&ep->ifm_media,
  307                                     ifmr->ifm_ulist + i, sizeof(int));
  308                                 if (error != 0)
  309                                         break;
  310                         }
  311                         i++;
  312                 }
  313                 if (error == 0 && i > ifmr->ifm_count)
  314                         error = ifmr->ifm_count != 0 ? E2BIG : 0;
  315                 ifmr->ifm_count = i;
  316                 break;
  317         }
  318 
  319         default:
  320                 return (EINVAL);
  321         }
  322 
  323         return (error);
  324 }
  325 
  326 /*
  327  * Find media entry matching a given ifm word.
  328  *
  329  */
  330 static struct ifmedia_entry *
  331 ifmedia_match(struct ifmedia *ifm, int target, int mask)
  332 {
  333         struct ifmedia_entry *match, *next;
  334 
  335         match = NULL;
  336         mask = ~mask;
  337 
  338         LIST_FOREACH(next, &ifm->ifm_list, ifm_list) {
  339                 if ((next->ifm_media & mask) == (target & mask)) {
  340 #if defined(IFMEDIA_DEBUG) || defined(DIAGNOSTIC)
  341                         if (match) {
  342                                 printf("ifmedia_match: multiple match for "
  343                                     "%#010x/%#010x\n", target, mask);
  344                         }
  345 #endif
  346                         match = next;
  347                 }
  348         }
  349 
  350         return (match);
  351 }
  352 
  353 /*
  354  * Compute the interface `baudrate' from the media, for the interface
  355  * metrics (used by routing daemons).
  356  */
  357 static const struct ifmedia_baudrate ifmedia_baudrate_descriptions[] =   
  358     IFM_BAUDRATE_DESCRIPTIONS;
  359 
  360 uint64_t
  361 ifmedia_baudrate(int mword)
  362 {
  363         int i;
  364 
  365         for (i = 0; ifmedia_baudrate_descriptions[i].ifmb_word != 0; i++) {
  366                 if (IFM_TYPE_MATCH(mword, ifmedia_baudrate_descriptions[i].
  367                     ifmb_word))
  368                         return (ifmedia_baudrate_descriptions[i].ifmb_baudrate);
  369         }
  370 
  371         /* Not known. */
  372         return (0);
  373 }
  374  
  375 #ifdef IFMEDIA_DEBUG
  376 static const struct ifmedia_description ifm_type_descriptions[] =
  377     IFM_TYPE_DESCRIPTIONS;
  378 
  379 static const struct ifmedia_description ifm_subtype_ethernet_descriptions[] =
  380     IFM_SUBTYPE_ETHERNET_DESCRIPTIONS;
  381 
  382 static const struct ifmedia_description
  383     ifm_subtype_ethernet_option_descriptions[] =
  384     IFM_SUBTYPE_ETHERNET_OPTION_DESCRIPTIONS;
  385 
  386 static const struct ifmedia_description ifm_subtype_ieee80211_descriptions[] =
  387     IFM_SUBTYPE_IEEE80211_DESCRIPTIONS;
  388 
  389 static const struct ifmedia_description
  390     ifm_subtype_ieee80211_option_descriptions[] =
  391     IFM_SUBTYPE_IEEE80211_OPTION_DESCRIPTIONS;
  392 
  393 static const struct ifmedia_description
  394     ifm_subtype_ieee80211_mode_descriptions[] =
  395     IFM_SUBTYPE_IEEE80211_MODE_DESCRIPTIONS;
  396 
  397 static const struct ifmedia_description ifm_subtype_atm_descriptions[] =
  398     IFM_SUBTYPE_ATM_DESCRIPTIONS;
  399 
  400 static const struct ifmedia_description ifm_subtype_atm_option_descriptions[] =
  401     IFM_SUBTYPE_ATM_OPTION_DESCRIPTIONS;
  402 
  403 static const struct ifmedia_description ifm_subtype_shared_descriptions[] =
  404     IFM_SUBTYPE_SHARED_DESCRIPTIONS;
  405 
  406 static const struct ifmedia_description ifm_shared_option_descriptions[] =
  407     IFM_SHARED_OPTION_DESCRIPTIONS;
  408 
  409 struct ifmedia_type_to_subtype {
  410         const struct ifmedia_description *subtypes;
  411         const struct ifmedia_description *options;
  412         const struct ifmedia_description *modes;
  413 };
  414 
  415 /* must be in the same order as IFM_TYPE_DESCRIPTIONS */
  416 static const struct ifmedia_type_to_subtype ifmedia_types_to_subtypes[] = {
  417         {
  418           &ifm_subtype_ethernet_descriptions[0],
  419           &ifm_subtype_ethernet_option_descriptions[0],
  420           NULL,
  421         },
  422         {
  423           &ifm_subtype_ieee80211_descriptions[0],
  424           &ifm_subtype_ieee80211_option_descriptions[0],
  425           &ifm_subtype_ieee80211_mode_descriptions[0]
  426         },
  427         {
  428           &ifm_subtype_atm_descriptions[0],
  429           &ifm_subtype_atm_option_descriptions[0],
  430           NULL,
  431         },
  432 };
  433 
  434 /*
  435  * print a media word.
  436  */
  437 static void
  438 ifmedia_printword(int ifmw)
  439 {
  440         const struct ifmedia_description *desc;
  441         const struct ifmedia_type_to_subtype *ttos;
  442         int seen_option = 0;
  443 
  444         /* Find the top-level interface type. */
  445         for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes;
  446             desc->ifmt_string != NULL; desc++, ttos++)
  447                 if (IFM_TYPE(ifmw) == desc->ifmt_word)
  448                         break;
  449         if (desc->ifmt_string == NULL) {
  450                 printf("<unknown type>\n");
  451                 return;
  452         }
  453         printf("%s", desc->ifmt_string);
  454 
  455         /* Any mode. */
  456         for (desc = ttos->modes; desc && desc->ifmt_string != NULL; desc++)
  457                 if (IFM_MODE(ifmw) == desc->ifmt_word) {
  458                         if (desc->ifmt_string != NULL)
  459                                 printf(" mode %s", desc->ifmt_string);
  460                         break;
  461                 }
  462 
  463         /*
  464          * Check for the shared subtype descriptions first, then the
  465          * type-specific ones.
  466          */
  467         for (desc = ifm_subtype_shared_descriptions;
  468             desc->ifmt_string != NULL; desc++)
  469                 if (IFM_SUBTYPE(ifmw) == desc->ifmt_word)
  470                         goto got_subtype;
  471 
  472         for (desc = ttos->subtypes; desc->ifmt_string != NULL; desc++)
  473                 if (IFM_SUBTYPE(ifmw) == desc->ifmt_word)
  474                         break;
  475         if (desc->ifmt_string == NULL) {
  476                 printf(" <unknown subtype>\n");
  477                 return;
  478         }
  479 
  480  got_subtype:
  481         printf(" %s", desc->ifmt_string);
  482 
  483         /*
  484          * Look for shared options.
  485          */
  486         for (desc = ifm_shared_option_descriptions;
  487             desc->ifmt_string != NULL; desc++) {
  488                 if (ifmw & desc->ifmt_word) {
  489                         if (seen_option == 0)
  490                                 printf(" <");
  491                         printf("%s%s", seen_option++ ? "," : "",
  492                             desc->ifmt_string);
  493                 }
  494         }
  495 
  496         /*
  497          * Look for subtype-specific options.
  498          */
  499         for (desc = ttos->options; desc->ifmt_string != NULL; desc++) {
  500                 if (ifmw & desc->ifmt_word) {
  501                         if (seen_option == 0)
  502                                 printf(" <");
  503                         printf("%s%s", seen_option++ ? "," : "",
  504                             desc->ifmt_string); 
  505                 }
  506         }
  507         printf("%s\n", seen_option ? ">" : "");
  508 }
  509 #endif /* IFMEDIA_DEBUG */
Cache object: c01adb294b621ff646f76da751400d2b
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/net/if_media.c

FreeBSD/Linux Kernel Cross Reference
sys/net/if_media.c
