src/functions/functions.device

   1 #!/bin/bash
   2 ###############################################################################
   3 #                                                                             #
   4 # IPFire.org - A linux based firewall                                         #
   5 # Copyright (C) 2010  Michael Tremer & Christian Schmidt                      #
   6 #                                                                             #
   7 # This program is free software: you can redistribute it and/or modify        #
   8 # it under the terms of the GNU General Public License as published by        #
   9 # the Free Software Foundation, either version 3 of the License, or           #
  10 # (at your option) any later version.                                         #
  11 #                                                                             #
  12 # This program is distributed in the hope that it will be useful,             #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  15 # GNU General Public License for more details.                                #
  16 #                                                                             #
  17 # You should have received a copy of the GNU General Public License           #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21
  22 declare -A DEVICE_LINK_SPEEDS=(
  23         [10BaseT-Half]=0x1
  24         [10BaseT-Full]=0x2
  25         [100BaseT-Half]=0x4
  26         [100BaseT-Full]=0x8
  27         [1000BaseT-Half]=0x10
  28         [1000BaseT-Full]=0x20
  29         [10000BaseT-Full]=0x1000
  30 )
  31
  32 device_list() {
  33         # Add all interfaces
  34         local device
  35         for device in $(list_directory ${SYS_CLASS_NET}); do
  36                 if device_exists "${device}"; then
  37                         print "${device}"
  38                 fi
  39         done
  40
  41         # List all PHYs
  42         phy_list
  43
  44         # List all serial devices
  45         serial_list
  46 }
  47
  48 # Check if the device exists
  49 device_exists() {
  50         local device=${1}
  51
  52         # If device name was not found, exit.
  53         [ -n "${device}" ] || return ${EXIT_ERROR}
  54
  55         # Check for a normal network device.
  56         [ -d "${SYS_CLASS_NET}/${device}" ] && return ${EXIT_OK}
  57
  58         # If the check above did not find a result,
  59         # we check for PHYs.
  60         phy_exists "${device}" && return ${EXIT_OK}
  61
  62         # If the check above did not find a result,
  63         # we check for serial devices.
  64         serial_exists ${device}
  65 }
  66
  67 device_matches_pattern() {
  68         local device="${1}"
  69         assert isset device
  70
  71         local pattern="${2}"
  72         assert isset pattern
  73
  74         pattern="^${pattern//N/[[:digit:]]+}$"
  75
  76         [[ ${device} =~ ${pattern} ]] \
  77                 && return ${EXIT_TRUE} || return ${EXIT_FALSE}
  78 }
  79
  80 device_delete() {
  81         local device=${1}
  82         assert isset device
  83
  84         # Nothing to do, it device does not exist.
  85         device_exists ${device} || return ${EXIT_OK}
  86
  87         # Shut down device before we delete it
  88         device_set_down "${device}"
  89
  90         # Delete the device.
  91         cmd_quiet ip link delete ${device}
  92         local ret=$?
  93
  94         if [ ${ret} -ne ${EXIT_OK} ]; then
  95                 log ERROR "device: Could not delete device '${device}': ${ret}"
  96                 return ${EXIT_ERROR}
  97         fi
  98
  99         return ${ret}
 100 }
 101
 102 device_has_flag() {
 103         local device=${1}
 104         local flag=${2}
 105
 106         local flags=$(__device_get_file ${device} flags)
 107
 108         if [[ "$(( ${flags} & ${flag} ))" -eq 0 ]]; then
 109                 return ${EXIT_FALSE}
 110         else
 111                 return ${EXIT_TRUE}
 112         fi
 113 }
 114
 115 # Check if the device is up
 116 device_is_up() {
 117         local device=${1}
 118
 119         device_exists ${device} || return ${EXIT_ERROR}
 120
 121         device_has_flag ${device} 0x1
 122 }
 123
 124 device_ifindex_to_name() {
 125         local idx=${1}
 126         assert isset idx
 127
 128         local device device_idx
 129         for device in $(list_directory "${SYS_CLASS_NET}"); do
 130                 device_idx=$(device_get_ifindex ${device})
 131
 132                 if [ "${device_idx}" = "${idx}" ]; then
 133                         print "${device}"
 134                         return ${EXIT_OK}
 135                 fi
 136         done
 137
 138         return ${EXIT_ERROR}
 139 }
 140
 141 device_get_ifindex() {
 142         local device=${1}
 143         assert isset device
 144
 145         local path="${SYS_CLASS_NET}/${1}/ifindex"
 146
 147         # Check if file can be read.
 148         [ -r "${path}" ] || return ${EXIT_ERROR}
 149
 150         print "$(<${path})"
 151 }
 152
 153 device_get_driver() {
 154         local device="${1}"
 155         assert isset device
 156
 157         get_driver_from_path "${SYS_CLASS_NET}/${device}/device/driver/module"
 158 }
 159
 160 # Check if the device is a bonding device
 161 device_is_bonding() {
 162         [ -d "/sys/class/net/${1}/bonding" ]
 163 }
 164
 165 # Check if the device bonded in a bonding device
 166 device_is_bonded() {
 167         local device=${1}
 168
 169         [ -d "${SYS_CLASS_NET}/${device}/bonding_slave" ]
 170 }
 171
 172 # Check if the device is a bridge
 173 device_is_bridge() {
 174         [ -d "/sys/class/net/${1}/bridge" ]
 175 }
 176
 177 device_is_bridge_attached() {
 178         local device=${1}
 179         [ -d "${SYS_CLASS_NET}/${device}/brport" ]
 180 }
 181
 182 device_is_wireless_monitor() {
 183         local device="${1}"
 184         assert isset device
 185
 186         device_is_wireless "${device}" && \
 187                 device_matches_pattern "${device}" "${PORT_PATTERN_WIRELESS_MONITOR}"
 188 }
 189
 190 device_is_wireless_adhoc() {
 191         local device="${1}"
 192         assert isset device
 193
 194         device_is_wireless "${device}" && \
 195                 device_matches_pattern "${device}" "${PORT_PATTERN_WIRELESS_ADHOC}"
 196 }
 197
 198 device_get_bridge() {
 199         local device=${1}
 200         assert isset device
 201
 202         # Check if device is attached to a bridge.
 203         device_is_bridge_attached ${device} || return ${EXIT_ERROR}
 204
 205         local ifindex_path="${SYS_CLASS_NET}/${device}/brport/bridge/ifindex"
 206         [ -r "${ifindex_path}" ] || return ${EXIT_ERROR}
 207
 208         local ifindex=$(<${ifindex_path})
 209         assert isset ifindex
 210
 211         device_ifindex_to_name ${ifindex}
 212 }
 213
 214 # Check if the device is a vlan device
 215 device_is_vlan() {
 216         local device=${1}
 217         assert isset device
 218
 219         [ -e "${PROC_NET_VLAN}/${device}" ]
 220 }
 221
 222 # Check if the device has vlan devices
 223 device_has_vlans() {
 224         local device=${1}
 225         assert isset device
 226
 227         if device_is_vlan ${device}; then
 228                 return ${EXIT_FALSE}
 229         fi
 230
 231         local vlans=$(device_get_vlans ${device})
 232         [ -n "${vlans}" ] && return ${EXIT_OK} || return ${EXIT_ERROR}
 233 }
 234
 235 device_get_vlans() {
 236         local device=${1}
 237         assert isset device
 238
 239         # If no 8021q module has been loaded into the kernel,
 240         # we cannot do anything.
 241         [ -r "${PROC_NET_VLAN_CONFIG}" ] || return ${EXIT_OK}
 242
 243         local dev spacer1 id spacer2 parent
 244         while read dev spacer1 id spacer2 parent; do
 245                 [ "${parent}" = "${device}" ] || continue
 246
 247                 print "${dev}"
 248         done < ${PROC_NET_VLAN_CONFIG}
 249 }
 250
 251 __device_type_matches() {
 252         local device="${1}"
 253         local type="${2}"
 254
 255         local _type="$(__device_get_file "${device}" "type")"
 256
 257         if [ "${type}" = "${_type}" ]; then
 258                 return ${EXIT_TRUE}
 259         fi
 260
 261         return ${EXIT_FALSE}
 262 }
 263
 264 # Check if the device is a ppp device
 265 device_is_ppp() {
 266         local device="${1}"
 267         assert isset device
 268
 269         __device_type_matches "${device}" 512
 270 }
 271
 272 # Check if the device is a pointopoint device.
 273 device_is_ptp() {
 274         local device=${1}
 275
 276         device_has_flag ${device} 0x10
 277 }
 278
 279 # Check if the device is a loopback device
 280 device_is_loopback() {
 281         local device=${1}
 282
 283         [ "${device}" = "lo" ]
 284 }
 285
 286 # Check if the device is a dummy device
 287 #  This is the worst possible check, but all I could come up with
 288 device_is_dummy() {
 289         local device="${1}"
 290
 291         [[ ${device} =~ ^dummy[0-9]+$ ]]
 292 }
 293
 294 # Check if the device is a wireless device
 295 device_is_wireless() {
 296         local device=${1}
 297
 298         [ -d "${SYS_CLASS_NET}/${device}/phy80211" ]
 299 }
 300
 301 device_is_gre() {
 302         local device="${1}"
 303         assert isset device
 304
 305         __device_type_matches "${device}" 778
 306 }
 307
 308 device_is_gre6() {
 309         local device="${1}"
 310         assert isset device
 311
 312         __device_type_matches "${device}" 823
 313 }
 314
 315 device_is_vti() {
 316         local device="${1}"
 317         assert isset device
 318
 319         __device_type_matches "${device}" 768
 320 }
 321
 322 device_is_vti6() {
 323         local device="${1}"
 324         assert isset device
 325
 326         __device_type_matches "${device}" 769
 327 }
 328
 329 device_get_phy() {
 330         local device="${1}"
 331
 332         if device_is_wireless "${device}"; then
 333                 print "$(<${SYS_CLASS_NET}/${device}/phy80211/name)"
 334                 return ${EXIT_OK}
 335         fi
 336
 337         return ${EXIT_ERROR}
 338 }
 339
 340 device_is_phy() {
 341         phy_exists "$@"
 342 }
 343
 344 device_is_serial() {
 345         serial_exists "$@"
 346 }
 347
 348 # Returns true if a device is a tun device
 349 device_is_tun() {
 350         local device="${1}"
 351
 352         [ -e "${SYS_CLASS_NET}/${device}/tun_flags" ]
 353 }
 354
 355 # Check if the device is a physical network interface
 356 device_is_ethernet() {
 357         local device=${1}
 358
 359         device_is_ethernet_compatible "${device}" || \
 360                 return ${EXIT_ERROR}
 361
 362         device_is_loopback ${device} && \
 363                 return ${EXIT_ERROR}
 364
 365         device_is_bonding ${device} &&  \
 366                 return ${EXIT_ERROR}
 367
 368         device_is_bridge ${device} && \
 369                 return ${EXIT_ERROR}
 370
 371         device_is_ppp ${device} && \
 372                 return ${EXIT_ERROR}
 373
 374         device_is_vlan ${device} && \
 375                 return ${EXIT_ERROR}
 376
 377         device_is_dummy ${device} && \
 378                 return ${EXIT_ERROR}
 379
 380         device_is_tun ${device} && \
 381                 return ${EXIT_ERROR}
 382
 383         return ${EXIT_OK}
 384 }
 385
 386 # Get the device type
 387 device_get_type() {
 388         local device=${1}
 389
 390         # If the device does not exist (happens on udev remove events),
 391         # we do not bother to run all checks.
 392         if ! device_exists "${device}"; then
 393                 echo "unknown"
 394
 395         elif device_is_vlan ${device}; then
 396                 echo "vlan"
 397
 398         elif device_is_bonding ${device}; then
 399                 echo "bonding"
 400
 401         elif device_is_bridge ${device}; then
 402                 echo "bridge"
 403
 404         elif device_is_ppp ${device}; then
 405                 echo "ppp"
 406
 407         elif device_is_loopback ${device}; then
 408                 echo "loopback"
 409
 410         elif device_is_wireless_adhoc ${device}; then
 411                 echo "wireless-adhoc"
 412
 413         elif device_is_wireless ${device}; then
 414                 echo "wireless"
 415
 416         elif device_is_dummy ${device}; then
 417                 echo "dummy"
 418
 419         elif device_is_tun ${device}; then
 420                 echo "tun"
 421
 422         elif device_is_ethernet ${device}; then
 423                 echo "ethernet"
 424
 425         elif device_is_serial ${device}; then
 426                 echo "serial"
 427
 428         elif device_is_phy ${device}; then
 429                 echo "phy"
 430
 431         else
 432                 echo "$(device_tunnel_get_type "${device}")"
 433         fi
 434 }
 435
 436 # This function just checks the types a ip-tunnel device usually have
 437 # so when we know that the device is an ip-tunnel device we save time
 438 device_tunnel_get_type() {
 439         local device=${1}
 440
 441         # If the device does not exist (happens on udev remove events),
 442         # we do not bother to run all checks.
 443         if ! device_exists "${device}"; then
 444                 echo "unknown"
 445
 446         elif device_is_vti ${device}; then
 447                 echo "vti"
 448
 449         elif device_is_vti6 ${device}; then
 450                 echo "vti6"
 451
 452         else
 453                 echo "unknown"
 454         fi
 455 }
 456
 457 device_is_ethernet_compatible() {
 458         local device="${1}"
 459
 460         # /sys/class/net/*/type must equal 1 for ethernet compatible devices
 461         local type="$(__device_get_file "${device}" "type")"
 462         [[ "${type}" = "1" ]]
 463 }
 464
 465 device_get_status() {
 466         local device=${1}
 467         assert isset device
 468
 469         local status=${STATUS_DOWN}
 470
 471         if device_is_up ${device}; then
 472                 status=${STATUS_UP}
 473
 474                 if ! device_has_carrier ${device}; then
 475                         status=${STATUS_NOCARRIER}
 476                 fi
 477         fi
 478
 479         echo "${status}"
 480 }
 481
 482 device_get_address() {
 483         local device=${1}
 484
 485         cat ${SYS_CLASS_NET}/${device}/address 2>/dev/null
 486 }
 487
 488 device_set_address() {
 489         assert [ $# -eq 2 ]
 490
 491         local device="${1}"
 492         local addr="${2}"
 493
 494         if ! device_exists "${device}"; then
 495                 error "Device '${device}' does not exist."
 496                 return ${EXIT_ERROR}
 497         fi
 498
 499         # Do nothing if the address has not changed
 500         local old_addr="$(device_get_address "${device}")"
 501         if [ -n "${old_addr}" -a "${addr}" = "${old_addr}" ]; then
 502                 return ${EXIT_OK}
 503         fi
 504
 505         log DEBUG "Setting address of '${device}' from '${old_addr}' to '${addr}'"
 506
 507         local up
 508         if device_is_up "${device}"; then
 509                 device_set_down "${device}"
 510                 up=1
 511         fi
 512
 513         ip link set "${device}" address "${addr}"
 514         local ret=$?
 515
 516         if [ "${up}" = "1" ]; then
 517                 device_set_up "${device}"
 518         fi
 519
 520         if [ "${ret}" != "0" ]; then
 521                 error_log "Could not set address '${addr}' on device '${device}'"
 522         fi
 523
 524         return ${ret}
 525 }
 526
 527 device_get() {
 528         local device
 529         for device in $(list_directory "${SYS_CLASS_NET}"); do
 530                 # bonding_masters is no device
 531                 [ "${device}" = "bonding_masters" ] && continue
 532
 533                 echo "${device}"
 534         done
 535
 536         return ${EXIT_OK}
 537 }
 538
 539 # Check if a device has a cable plugged in
 540 device_has_carrier() {
 541         local device=${1}
 542         assert isset device
 543
 544         local carrier=$(__device_get_file ${device} carrier)
 545         [ "${carrier}" = "1" ]
 546 }
 547
 548 device_is_promisc() {
 549         local device=${1}
 550
 551         device_has_flag ${device} 0x200
 552 }
 553
 554 device_set_promisc() {
 555         local device=${1}
 556         local state=${2}
 557
 558         assert device_exists ${device}
 559         assert isset state
 560         assert isoneof state on off
 561
 562         ip link set ${device} promisc ${state}
 563 }
 564
 565 # Check if the device is free
 566 device_is_free() {
 567         ! device_is_used "$@"
 568 }
 569
 570 # Check if the device is used
 571 device_is_used() {
 572         local device=${1}
 573
 574         device_has_vlans ${device} && \
 575                 return ${EXIT_OK}
 576         device_is_bonded ${device} && \
 577                 return ${EXIT_OK}
 578         device_is_bridge_attached ${device} && \
 579                 return ${EXIT_OK}
 580
 581         return ${EXIT_ERROR}
 582 }
 583
 584 # Give the device a new name
 585 device_set_name() {
 586         local source=$1
 587         local destination=${2}
 588
 589         # Check if devices exists
 590         if ! device_exists ${source} || device_exists ${destination}; then
 591                 return 4
 592         fi
 593
 594         local up
 595         if device_is_up ${source}; then
 596                 ip link set ${source} down
 597                 up=1
 598         fi
 599
 600         ip link set ${source} name ${destination}
 601
 602         if [ "${up}" = "1" ]; then
 603                 ip link set ${destination} up
 604         fi
 605 }
 606
 607 device_set_master() {
 608         local device="${1}"
 609         assert isset device
 610
 611         local master="${2}"
 612         assert isset master
 613
 614         if ! cmd ip link set "${device}" master "${master}"; then
 615                 log ERROR "Could not set master ${master} for device ${device}"
 616                 return ${EXIT_ERROR}
 617         fi
 618
 619         return ${EXIT_OK}
 620 }
 621
 622 device_remove_master() {
 623         local device="${1}"
 624         assert isset device
 625
 626         if ! cmd ip link set "${device}" nomaster; then
 627                 log ERROR "Could not remove master for device ${device}"
 628                 return ${EXIT_ERROR}
 629         fi
 630
 631         return ${EXIT_OK}
 632 }
 633
 634 # Set device up
 635 device_set_up() {
 636         assert [ $# -eq 1 ]
 637
 638         local device=${1}
 639
 640         # Do nothing if device is already up
 641         device_is_up ${device} && return ${EXIT_OK}
 642
 643         log INFO "Bringing up ${device}"
 644
 645         device_set_parent_up ${device}
 646         if ! cmd ip link set ${device} up; then
 647                 return ${EXIT_ERROR}
 648         fi
 649
 650         # Set SMP affinity
 651         if interrupt_use_smp_affinity; then
 652                 device_auto_configure_smp_affinity ${device}
 653         fi
 654
 655         return ${EXIT_OK}
 656 }
 657
 658 device_set_parent_up() {
 659         local device=${1}
 660         local parent
 661
 662         if device_is_vlan ${device}; then
 663                 parent=$(vlan_get_parent ${device})
 664
 665                 device_is_up ${parent} && return ${EXIT_OK}
 666
 667                 log DEBUG "Setting up parent device '${parent}' of '${device}'"
 668
 669                 device_set_up ${parent}
 670                 return $?
 671         fi
 672
 673         return ${EXIT_OK}
 674 }
 675
 676 # Set device down
 677 device_set_down() {
 678         assert [ $# -eq 1 ]
 679
 680         local device=${1}
 681         local ret=${EXIT_OK}
 682
 683         if device_is_up ${device}; then
 684                 log INFO "Bringing down ${device}"
 685
 686                 cmd ip link set ${device} down
 687                 ret=$?
 688         fi
 689
 690         device_set_parent_down ${device}
 691
 692         return ${ret}
 693 }
 694
 695 device_set_parent_down() {
 696         local device=${1}
 697         local parent
 698
 699         if device_is_vlan ${device}; then
 700                 parent=$(vlan_get_parent ${device})
 701
 702                 device_is_up ${parent} || return ${EXIT_OK}
 703
 704                 if device_is_free ${parent}; then
 705                         log DEBUG "Tearing down parent device '${parent}' of '${device}'"
 706
 707                         device_set_down ${parent}
 708                 fi
 709         fi
 710
 711         return ${EXIT_OK}
 712 }
 713
 714 device_get_mtu() {
 715         local device=${1}
 716
 717         # Return an error if the device does not exist
 718         device_exists ${device} || return ${EXIT_ERROR}
 719
 720         echo $(<${SYS_CLASS_NET}/${device}/mtu)
 721 }
 722
 723 # Set mtu to a device
 724 device_set_mtu() {
 725         local device=${1}
 726         local mtu=${2}
 727
 728         assert device_exists ${device}
 729
 730         # Handle bridges differently
 731         if device_is_bridge ${device}; then
 732                 local port
 733                 for port in $(bridge_get_members ${device}); do
 734                         device_set_mtu ${port} ${mtu}
 735                 done
 736         fi
 737
 738         log INFO "Setting MTU of ${device} to ${mtu}"
 739
 740         local up
 741         if device_is_up ${device}; then
 742                 device_set_down ${device}
 743                 up=1
 744         fi
 745
 746         local ret=${EXIT_OK}
 747         if ! cmd ip link set ${device} mtu ${mtu}; then
 748                 ret=${EXIT_ERROR}
 749
 750                 log ERROR "Could not set MTU ${mtu} on ${device}"
 751         fi
 752
 753         if [ "${up}" = "1" ]; then
 754                 device_set_up ${device}
 755         fi
 756
 757         return ${ret}
 758 }
 759
 760 device_adjust_mtu() {
 761         assert [ $# -eq 2 ]
 762
 763         local device="${1}"
 764         local other_device="${2}"
 765
 766         local mtu="$(device_get_mtu "${other_device}")"
 767         device_set_mtu "${device}" "${mtu}"
 768 }
 769
 770 device_discover() {
 771         local device=${1}
 772
 773         log INFO "Running discovery process on device '${device}'."
 774
 775         local hook
 776         for hook in $(hook_zone_get_all); do
 777                 hook_zone_exec ${hook} discover ${device}
 778         done
 779 }
 780
 781 device_identify() {
 782         assert [ $# -ge 1 ]
 783
 784         local device="${1}"
 785
 786         # Flash for ten seconds by default
 787         local seconds="10"
 788
 789         # Run in background?
 790         local background="false"
 791
 792         local arg
 793         while read arg; do
 794                 case "${arg}" in
 795                         --background)
 796                                 background="true"
 797                                 ;;
 798                         --seconds=*)
 799                                 seconds="$(cli_get_val "${arg}")"
 800                                 ;;
 801                 esac
 802         done <<< "$(args "$@")"
 803
 804         assert isinteger seconds
 805
 806         if ! device_exists "${device}"; then
 807                 log ERROR "Cannot identify device ${device}: Does not exist"
 808                 return ${EXIT_ERROR}
 809         fi
 810
 811         if ! device_is_ethernet "${device}"; then
 812                 log DEBUG "Cannot identify device ${device}: Not an ethernet device"
 813                 return ${EXIT_NOT_SUPPORTED}
 814         fi
 815
 816         log DEBUG "Identifying device ${device}"
 817
 818         local command="ethtool --identify ${device} ${seconds}"
 819         local ret=0
 820
 821         if enabled background; then
 822                 cmd_background "${command}"
 823         else
 824                 cmd_quiet "${command}"
 825                 ret=$?
 826         fi
 827
 828         return ${ret}
 829 }
 830
 831 device_has_ip() {
 832         local device=${1}
 833         local addr=${2}
 834
 835         assert isset addr
 836         assert device_exists ${device}
 837
 838         # IPv6 addresses must be fully imploded
 839         local protocol=$(ip_detect_protocol ${addr})
 840         case "${protocol}" in
 841                 ipv6)
 842                         addr=$(ipv6_format "${addr}")
 843                         ;;
 844         esac
 845
 846         list_match ${addr} $(device_get_addresses ${device})
 847 }
 848
 849 device_get_addresses() {
 850         local device=${1}
 851
 852         assert device_exists ${device}
 853
 854         local prot
 855         local addr
 856         local line
 857         ip addr show ${device} | \
 858                 while read prot addr line; do
 859                         [ "${prot:0:4}" = "inet" ] && echo "${addr}"
 860                 done
 861 }
 862
 863 __device_get_file() {
 864         local device=${1}
 865         local file=${2}
 866
 867         fread "${SYS_CLASS_NET}/${device}/${file}"
 868 }
 869
 870 __device_set_file() {
 871         assert [ $# -eq 3 ]
 872
 873         local device="${1}"
 874         local file="${2}"
 875         local value="${3}"
 876
 877         fappend "${SYS_CLASS_NET}/${device}/${file}" "${value}"
 878 }
 879
 880 device_get_rx_bytes() {
 881         local device=${1}
 882
 883         __device_get_file ${device} statistics/rx_bytes
 884 }
 885
 886 device_get_tx_bytes() {
 887         local device=${1}
 888
 889         __device_get_file ${device} statistics/tx_bytes
 890 }
 891
 892 device_get_rx_packets() {
 893         local device=${1}
 894
 895         __device_get_file ${device} statistics/rx_packets
 896 }
 897
 898 device_get_tx_packets() {
 899         local device=${1}
 900
 901         __device_get_file ${device} statistics/tx_packets
 902 }
 903
 904 device_get_rx_errors() {
 905         local device=${1}
 906
 907         __device_get_file ${device} statistics/rx_errors
 908 }
 909
 910 device_get_tx_errors() {
 911         local device=${1}
 912
 913         __device_get_file ${device} statistics/tx_errors
 914 }
 915
 916 device_advertise_link_speeds() {
 917         local device="${1}"
 918         shift
 919
 920         assert isset device
 921
 922         # Advertised modes in hex
 923         local advertise=0
 924
 925         local mode
 926         for mode in $@; do
 927                 local m="${DEVICE_LINK_SPEEDS[${mode}]}"
 928                 if isset m; then
 929                         advertise="$(( advertise | m ))"
 930                 fi
 931         done
 932
 933         # If nothing was selected, we reset and enable everything
 934         if [ ${advertise} -eq 0 ]; then
 935                 advertise=0xffffff
 936         fi
 937
 938         # Enable auto-negotiation
 939         cmd_quiet ethtool --change "${device}" autoneg on
 940
 941         # Set advertised link speeds
 942         if ! cmd_quiet ethtool --change "${device}" advertise "0x$(hex "${advertise}")"; then
 943                 log ERROR "Could not set link modes of ${device}: $@"
 944                 return ${EXIT_ERROR}
 945         fi
 946
 947         log DEBUG "Set device link modes of ${device} to $@"
 948         return ${EXIT_ERROR}
 949 }
 950
 951 device_get_speed() {
 952         local device=${1}
 953
 954         local speed=$(__device_get_file ${device} speed)
 955
 956         # Exit for no output (i.e. no link detected)
 957         isset speed || return ${EXIT_ERROR}
 958
 959         # Don't return anything for negative values
 960         [ ${speed} -lt 0 ] && return ${EXIT_ERROR}
 961
 962         print "${speed}"
 963 }
 964
 965 device_get_duplex() {
 966         local device=${1}
 967
 968         local duplex=$(__device_get_file ${device} duplex)
 969
 970         case "${duplex}" in
 971                 unknown)
 972                         return ${EXIT_ERROR}
 973                         ;;
 974                 *)
 975                         print "${duplex}"
 976                         ;;
 977         esac
 978 }
 979
 980 device_get_link_string() {
 981         local device="${1}"
 982         assert isset device
 983
 984         local s
 985
 986         local speed="$(device_get_speed "${device}")"
 987         if isset speed; then
 988                 list_append s "${speed} MBit/s"
 989         fi
 990
 991         local duplex="$(device_get_duplex "${device}")"
 992         if isset duplex; then
 993                 list_append s "${duplex} duplex"
 994         fi
 995
 996         print "${s}"
 997 }
 998
 999 device_auto_configure_smp_affinity() {
1000         local device="${1}"
1001         assert isset device
1002
1003         lock "smp-affinity" \
1004                 device_set_smp_affinity "${device}" "auto"
1005 }
1006
1007 device_set_smp_affinity() {
1008         assert [ $# -eq 2 ]
1009
1010         local device=${1}
1011         local mode=${2}
1012
1013         # mode can be auto which will automatically try to find
1014         # the least busy processor, or an integer for the desired
1015         # processor that should handle this device
1016
1017         local num_processors=$(system_get_processors)
1018
1019         if [ "${mode}" = "auto" ]; then
1020                 local processor=$(interrupt_choose_least_busy_processor)
1021         else
1022                 assert isinteger mode
1023                 local processor=${mode}
1024
1025                 if [ ${processor} -gt ${num_processors} ]; then
1026                         log ERROR "Processor ${processor} does not exist"
1027                         return ${EXIT_ERROR}
1028                 fi
1029         fi
1030
1031         local interrupts=$(interrupts_for_device ${device})
1032         if ! isset interrupts; then
1033                 log DEBUG "${device} has no interrupts. Not changing SMP affinity"
1034                 return ${EXIT_OK}
1035         fi
1036
1037         # Set SMP affinity
1038         local interrupt
1039         for interrupt in ${interrupts}; do
1040                 interrupt_set_smp_affinity ${interrupt} ${processor}
1041         done
1042
1043         # Find all queues and assign them to the next processor
1044         local queue
1045         for queue in $(device_get_queues ${device}); do
1046                 case "${queue}" in
1047                         # Only handle receive queues
1048                         rx-*)
1049                                 for interrupt in $(interrupts_for_device_queue ${device} ${queue}); do
1050                                         interrupt_set_smp_affinity ${interrupt} ${processor}
1051                                 done
1052
1053                                 device_queue_set_smp_affinity ${device} ${queue} ${processor}
1054                                 ;;
1055
1056                         # Ignore the rest
1057                         *)
1058                                 continue
1059                                 ;;
1060                 esac
1061
1062                 # Get the next available processor if in auto mode
1063                 [ "${mode}" = "auto" ] && processor=$(system_get_next_processor ${processor})
1064         done
1065
1066         return ${EXIT_OK}
1067 }
1068
1069 device_get_queues() {
1070         assert [ $# -eq 1 ]
1071
1072         local device=${1}
1073
1074         list_directory "${SYS_CLASS_NET}/${device}/queues"
1075 }
1076
1077 device_supports_multiqueue() {
1078         local device=${1}
1079
1080         local num_queues=$(device_num_queues ${device})
1081
1082         if isset num_queues && [ ${num_queues} -gt 2 ]; then
1083                 return ${EXIT_TRUE}
1084         fi
1085
1086         return ${EXIT_FALSE}
1087 }
1088
1089 device_num_queues() {
1090         local device=${1}
1091         local type=${2}
1092
1093         isset type && assert isoneof type rx tx
1094
1095         local i=0
1096
1097         local q
1098         for q in $(device_get_queues ${device}); do
1099                 case "${type},${q}" in
1100                         rx,rx-*)
1101                                 (( i++ ))
1102                                 ;;
1103                         tx,tx-*)
1104                                 (( i++ ))
1105                                 ;;
1106                         *,*)
1107                                 (( i++ ))
1108                                 ;;
1109                 esac
1110         done
1111
1112         print ${i}
1113 }
1114
1115 device_queue_get_smp_affinity() {
1116         assert [ $# -eq 2 ]
1117
1118         local device=${1}
1119         local queue=${2}
1120
1121         local path="${SYS_CLASS_NET}/${device}/queues/${queue}"
1122
1123         case "${queue}" in
1124                 rx-*)
1125                         path="${path}/rps_cpus"
1126                         ;;
1127                 tx-*)
1128                         path="${path}/xps_cpus"
1129                         ;;
1130         esac
1131         assert [ -r "${path}" ]
1132
1133         __bitmap_to_processor_ids $(<${path})
1134 }
1135
1136 device_queue_set_smp_affinity() {
1137         assert [ $# -eq 3 ]
1138
1139         local device=${1}
1140         local queue=${2}
1141         local processor=${3}
1142
1143         local path="${SYS_CLASS_NET}/${device}/queues/${queue}/rps_cpus"
1144         assert [ -w "${path}" ]
1145
1146         log DEBUG "Setting SMP affinity of ${device} (${queue}) to processor ${processor}"
1147
1148         __processor_id_to_bitmap ${processor} > ${path}
1149 }
1150
1151 # Tries to find a device which has the given IP address assigned
1152 device_get_by_assigned_ip_address() {
1153         local ip=${1}
1154
1155         assert isset ip
1156
1157         local device
1158
1159         # Read the first line of ip addr show to
1160         read -r device <<< $(ip addr show to "${ip}")
1161
1162         # If we did not found a device we return with ${EXIT_ERROR}
1163         if ! isset device; then
1164                 return ${EXIT_ERROR}
1165         fi
1166
1167         # We get something like:
1168         # 3: upl0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
1169         # and we want upl0 so we take the second word and removing the :
1170         device=(${device})
1171         device=${device[1]}
1172         device=${device%:}
1173
1174         print "${device}"
1175         return ${EXIT_OK}
1176 }
1177
1178 device_get_by_mac_address() {
1179         local mac=${1}
1180
1181         assert isset mac
1182
1183         local device
1184
1185         for device in $(device_list); do
1186                 if [ "${mac}" = "$(device_get_address ${device})" ]; then
1187                         print "${device}"
1188                         return ${EXIT_OK}
1189                 fi
1190         done
1191
1192         # We could not found a port to the given mac address so we return exit error
1193         return ${EXIT_ERROR}
1194 }