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 # Check if the device is a ppp device
 252 device_is_ppp() {
 253         local device=${1}
 254
 255         local type=$(__device_get_file ${device} type)
 256
 257         [ "${type}" = "512" ] && return ${EXIT_OK} || return ${EXIT_ERROR}
 258 }
 259
 260 # Check if the device is a pointopoint device.
 261 device_is_ptp() {
 262         local device=${1}
 263
 264         device_has_flag ${device} 0x10
 265 }
 266
 267 # Check if the device is a loopback device
 268 device_is_loopback() {
 269         local device=${1}
 270
 271         [ "${device}" = "lo" ]
 272 }
 273
 274 # Check if the device is a dummy device
 275 #  This is the worst possible check, but all I could come up with
 276 device_is_dummy() {
 277         local device="${1}"
 278
 279         [[ ${device} =~ ^dummy[0-9]+$ ]]
 280 }
 281
 282 device_is_ipsec() {
 283         local device="${1}"
 284
 285         [[ ${device} =~ ^ipsec\- ]]
 286 }
 287
 288 # Check if the device is a wireless device
 289 device_is_wireless() {
 290         local device=${1}
 291
 292         [ -d "${SYS_CLASS_NET}/${device}/phy80211" ]
 293 }
 294
 295 device_is_vti() {
 296         local device=${1}
 297
 298         local type=$(__device_get_file ${device} type)
 299
 300         [ "${type}" = "768" ] && return ${EXIT_OK} || return ${EXIT_ERROR}
 301 }
 302
 303 device_is_vti6() {
 304         local device=${1}
 305
 306         local type=$(__device_get_file ${device} type)
 307
 308         [ "${type}" = "769" ] && return ${EXIT_OK} || return ${EXIT_ERROR}
 309 }
 310
 311 device_get_phy() {
 312         local device="${1}"
 313
 314         if device_is_wireless "${device}"; then
 315                 print "$(<${SYS_CLASS_NET}/${device}/phy80211/name)"
 316                 return ${EXIT_OK}
 317         fi
 318
 319         return ${EXIT_ERROR}
 320 }
 321
 322 device_is_phy() {
 323         phy_exists "$@"
 324 }
 325
 326 device_is_serial() {
 327         serial_exists "$@"
 328 }
 329
 330 # Returns true if a device is a tun device
 331 device_is_tun() {
 332         local device="${1}"
 333
 334         [ -e "${SYS_CLASS_NET}/${device}/tun_flags" ]
 335 }
 336
 337 # Check if the device is a physical network interface
 338 device_is_ethernet() {
 339         local device=${1}
 340
 341         device_is_ethernet_compatible "${device}" || \
 342                 return ${EXIT_ERROR}
 343
 344         device_is_loopback ${device} && \
 345                 return ${EXIT_ERROR}
 346
 347         device_is_bonding ${device} &&  \
 348                 return ${EXIT_ERROR}
 349
 350         device_is_bridge ${device} && \
 351                 return ${EXIT_ERROR}
 352
 353         device_is_ppp ${device} && \
 354                 return ${EXIT_ERROR}
 355
 356         device_is_vlan ${device} && \
 357                 return ${EXIT_ERROR}
 358
 359         device_is_dummy ${device} && \
 360                 return ${EXIT_ERROR}
 361
 362         device_is_tun ${device} && \
 363                 return ${EXIT_ERROR}
 364
 365         return ${EXIT_OK}
 366 }
 367
 368 # Get the device type
 369 device_get_type() {
 370         local device=${1}
 371
 372         # If the device does not exist (happens on udev remove events),
 373         # we do not bother to run all checks.
 374         if ! device_exists "${device}"; then
 375                 echo "unknown"
 376
 377         elif device_is_vlan ${device}; then
 378                 echo "vlan"
 379
 380         elif device_is_bonding ${device}; then
 381                 echo "bonding"
 382
 383         elif device_is_bridge ${device}; then
 384                 echo "bridge"
 385
 386         elif device_is_ppp ${device}; then
 387                 echo "ppp"
 388
 389         elif device_is_loopback ${device}; then
 390                 echo "loopback"
 391
 392         elif device_is_wireless_adhoc ${device}; then
 393                 echo "wireless-adhoc"
 394
 395         elif device_is_wireless ${device}; then
 396                 echo "wireless"
 397
 398         elif device_is_dummy ${device}; then
 399                 echo "dummy"
 400
 401         elif device_is_tun ${device}; then
 402                 echo "tun"
 403
 404         elif device_is_ethernet ${device}; then
 405                 echo "ethernet"
 406
 407         elif device_is_serial ${device}; then
 408                 echo "serial"
 409
 410         elif device_is_phy ${device}; then
 411                 echo "phy"
 412
 413         else
 414                 echo "$(device_tunnel_get_type "${device}")"
 415         fi
 416 }
 417
 418 # This function just checks the types a ip-tunnel device usually have
 419 # so when we know that the device is an ip-tunnel device we save time
 420 device_tunnel_get_type() {
 421         local device=${1}
 422
 423         # If the device does not exist (happens on udev remove events),
 424         # we do not bother to run all checks.
 425         if ! device_exists "${device}"; then
 426                 echo "unknown"
 427
 428         elif device_is_vti ${device}; then
 429                 echo "vti"
 430
 431         elif device_is_vti6 ${device}; then
 432                 echo "vti6"
 433
 434         else
 435                 echo "unknown"
 436         fi
 437 }
 438
 439 device_is_ethernet_compatible() {
 440         local device="${1}"
 441
 442         # /sys/class/net/*/type must equal 1 for ethernet compatible devices
 443         local type="$(__device_get_file "${device}" "type")"
 444         [[ "${type}" = "1" ]]
 445 }
 446
 447 device_get_status() {
 448         local device=${1}
 449         assert isset device
 450
 451         local status=${STATUS_DOWN}
 452
 453         if device_is_up ${device}; then
 454                 status=${STATUS_UP}
 455
 456                 if ! device_has_carrier ${device}; then
 457                         status=${STATUS_NOCARRIER}
 458                 fi
 459         fi
 460
 461         echo "${status}"
 462 }
 463
 464 device_get_address() {
 465         local device=${1}
 466
 467         cat ${SYS_CLASS_NET}/${device}/address 2>/dev/null
 468 }
 469
 470 device_set_address() {
 471         assert [ $# -eq 2 ]
 472
 473         local device="${1}"
 474         local addr="${2}"
 475
 476         if ! device_exists "${device}"; then
 477                 error "Device '${device}' does not exist."
 478                 return ${EXIT_ERROR}
 479         fi
 480
 481         # Do nothing if the address has not changed
 482         local old_addr="$(device_get_address "${device}")"
 483         if [ -n "${old_addr}" -a "${addr}" = "${old_addr}" ]; then
 484                 return ${EXIT_OK}
 485         fi
 486
 487         log DEBUG "Setting address of '${device}' from '${old_addr}' to '${addr}'"
 488
 489         local up
 490         if device_is_up "${device}"; then
 491                 device_set_down "${device}"
 492                 up=1
 493         fi
 494
 495         ip link set "${device}" address "${addr}"
 496         local ret=$?
 497
 498         if [ "${up}" = "1" ]; then
 499                 device_set_up "${device}"
 500         fi
 501
 502         if [ "${ret}" != "0" ]; then
 503                 error_log "Could not set address '${addr}' on device '${device}'"
 504         fi
 505
 506         return ${ret}
 507 }
 508
 509 device_get() {
 510         local device
 511         for device in $(list_directory "${SYS_CLASS_NET}"); do
 512                 # bonding_masters is no device
 513                 [ "${device}" = "bonding_masters" ] && continue
 514
 515                 echo "${device}"
 516         done
 517
 518         return ${EXIT_OK}
 519 }
 520
 521 # Check if a device has a cable plugged in
 522 device_has_carrier() {
 523         local device=${1}
 524         assert isset device
 525
 526         local carrier=$(__device_get_file ${device} carrier)
 527         [ "${carrier}" = "1" ]
 528 }
 529
 530 device_is_promisc() {
 531         local device=${1}
 532
 533         device_has_flag ${device} 0x200
 534 }
 535
 536 device_set_promisc() {
 537         local device=${1}
 538         local state=${2}
 539
 540         assert device_exists ${device}
 541         assert isset state
 542         assert isoneof state on off
 543
 544         ip link set ${device} promisc ${state}
 545 }
 546
 547 # Check if the device is free
 548 device_is_free() {
 549         ! device_is_used "$@"
 550 }
 551
 552 # Check if the device is used
 553 device_is_used() {
 554         local device=${1}
 555
 556         device_has_vlans ${device} && \
 557                 return ${EXIT_OK}
 558         device_is_bonded ${device} && \
 559                 return ${EXIT_OK}
 560         device_is_bridge_attached ${device} && \
 561                 return ${EXIT_OK}
 562
 563         return ${EXIT_ERROR}
 564 }
 565
 566 # Give the device a new name
 567 device_set_name() {
 568         local source=$1
 569         local destination=${2}
 570
 571         # Check if devices exists
 572         if ! device_exists ${source} || device_exists ${destination}; then
 573                 return 4
 574         fi
 575
 576         local up
 577         if device_is_up ${source}; then
 578                 ip link set ${source} down
 579                 up=1
 580         fi
 581
 582         ip link set ${source} name ${destination}
 583
 584         if [ "${up}" = "1" ]; then
 585                 ip link set ${destination} up
 586         fi
 587 }
 588
 589 device_set_master() {
 590         local device="${1}"
 591         assert isset device
 592
 593         local master="${2}"
 594         assert isset master
 595
 596         if ! cmd ip link set "${device}" master "${master}"; then
 597                 log ERROR "Could not set master ${master} for device ${device}"
 598                 return ${EXIT_ERROR}
 599         fi
 600
 601         return ${EXIT_OK}
 602 }
 603
 604 device_remove_master() {
 605         local device="${1}"
 606         assert isset device
 607
 608         if ! cmd ip link set "${device}" nomaster; then
 609                 log ERROR "Could not remove master for device ${device}"
 610                 return ${EXIT_ERROR}
 611         fi
 612
 613         return ${EXIT_OK}
 614 }
 615
 616 # Set device up
 617 device_set_up() {
 618         assert [ $# -eq 1 ]
 619
 620         local device=${1}
 621
 622         # Do nothing if device is already up
 623         device_is_up ${device} && return ${EXIT_OK}
 624
 625         log INFO "Bringing up ${device}"
 626
 627         device_set_parent_up ${device}
 628         if ! cmd ip link set ${device} up; then
 629                 return ${EXIT_ERROR}
 630         fi
 631
 632         # Set SMP affinity
 633         if interrupt_use_smp_affinity; then
 634                 device_auto_configure_smp_affinity ${device}
 635         fi
 636
 637         return ${EXIT_OK}
 638 }
 639
 640 device_set_parent_up() {
 641         local device=${1}
 642         local parent
 643
 644         if device_is_vlan ${device}; then
 645                 parent=$(vlan_get_parent ${device})
 646
 647                 device_is_up ${parent} && return ${EXIT_OK}
 648
 649                 log DEBUG "Setting up parent device '${parent}' of '${device}'"
 650
 651                 device_set_up ${parent}
 652                 return $?
 653         fi
 654
 655         return ${EXIT_OK}
 656 }
 657
 658 # Set device down
 659 device_set_down() {
 660         assert [ $# -eq 1 ]
 661
 662         local device=${1}
 663         local ret=${EXIT_OK}
 664
 665         if device_is_up ${device}; then
 666                 log INFO "Bringing down ${device}"
 667
 668                 cmd ip link set ${device} down
 669                 ret=$?
 670         fi
 671
 672         device_set_parent_down ${device}
 673
 674         return ${ret}
 675 }
 676
 677 device_set_parent_down() {
 678         local device=${1}
 679         local parent
 680
 681         if device_is_vlan ${device}; then
 682                 parent=$(vlan_get_parent ${device})
 683
 684                 device_is_up ${parent} || return ${EXIT_OK}
 685
 686                 if device_is_free ${parent}; then
 687                         log DEBUG "Tearing down parent device '${parent}' of '${device}'"
 688
 689                         device_set_down ${parent}
 690                 fi
 691         fi
 692
 693         return ${EXIT_OK}
 694 }
 695
 696 device_get_mtu() {
 697         local device=${1}
 698
 699         # Return an error if the device does not exist
 700         device_exists ${device} || return ${EXIT_ERROR}
 701
 702         echo $(<${SYS_CLASS_NET}/${device}/mtu)
 703 }
 704
 705 # Set mtu to a device
 706 device_set_mtu() {
 707         local device=${1}
 708         local mtu=${2}
 709
 710         assert device_exists ${device}
 711
 712         # Handle bridges differently
 713         if device_is_bridge ${device}; then
 714                 local port
 715                 for port in $(bridge_get_members ${device}); do
 716                         device_set_mtu ${port} ${mtu}
 717                 done
 718         fi
 719
 720         log INFO "Setting MTU of ${device} to ${mtu}"
 721
 722         local up
 723         if device_is_up ${device}; then
 724                 device_set_down ${device}
 725                 up=1
 726         fi
 727
 728         local ret=${EXIT_OK}
 729         if ! cmd ip link set ${device} mtu ${mtu}; then
 730                 ret=${EXIT_ERROR}
 731
 732                 log ERROR "Could not set MTU ${mtu} on ${device}"
 733         fi
 734
 735         if [ "${up}" = "1" ]; then
 736                 device_set_up ${device}
 737         fi
 738
 739         return ${ret}
 740 }
 741
 742 device_adjust_mtu() {
 743         assert [ $# -eq 2 ]
 744
 745         local device="${1}"
 746         local other_device="${2}"
 747
 748         local mtu="$(device_get_mtu "${other_device}")"
 749         device_set_mtu "${device}" "${mtu}"
 750 }
 751
 752 device_discover() {
 753         local device=${1}
 754
 755         log INFO "Running discovery process on device '${device}'."
 756
 757         local hook
 758         for hook in $(hook_zone_get_all); do
 759                 hook_zone_exec ${hook} discover ${device}
 760         done
 761 }
 762
 763 device_identify() {
 764         assert [ $# -ge 1 ]
 765
 766         local device="${1}"
 767
 768         # Flash for ten seconds by default
 769         local seconds="10"
 770
 771         # Run in background?
 772         local background="false"
 773
 774         local arg
 775         while read arg; do
 776                 case "${arg}" in
 777                         --background)
 778                                 background="true"
 779                                 ;;
 780                         --seconds=*)
 781                                 seconds="$(cli_get_val "${arg}")"
 782                                 ;;
 783                 esac
 784         done <<< "$(args "$@")"
 785
 786         assert isinteger seconds
 787
 788         if ! device_exists "${device}"; then
 789                 log ERROR "Cannot identify device ${device}: Does not exist"
 790                 return ${EXIT_ERROR}
 791         fi
 792
 793         if ! device_is_ethernet "${device}"; then
 794                 log DEBUG "Cannot identify device ${device}: Not an ethernet device"
 795                 return ${EXIT_NOT_SUPPORTED}
 796         fi
 797
 798         log DEBUG "Identifying device ${device}"
 799
 800         local command="ethtool --identify ${device} ${seconds}"
 801         local ret=0
 802
 803         if enabled background; then
 804                 cmd_background "${command}"
 805         else
 806                 cmd_quiet "${command}"
 807                 ret=$?
 808         fi
 809
 810         return ${ret}
 811 }
 812
 813 device_has_ip() {
 814         local device=${1}
 815         local addr=${2}
 816
 817         assert isset addr
 818         assert device_exists ${device}
 819
 820         # IPv6 addresses must be fully imploded
 821         local protocol=$(ip_detect_protocol ${addr})
 822         case "${protocol}" in
 823                 ipv6)
 824                         addr=$(ipv6_format "${addr}")
 825                         ;;
 826         esac
 827
 828         list_match ${addr} $(device_get_addresses ${device})
 829 }
 830
 831 device_get_addresses() {
 832         local device=${1}
 833
 834         assert device_exists ${device}
 835
 836         local prot
 837         local addr
 838         local line
 839         ip addr show ${device} | \
 840                 while read prot addr line; do
 841                         [ "${prot:0:4}" = "inet" ] && echo "${addr}"
 842                 done
 843 }
 844
 845 __device_get_file() {
 846         local device=${1}
 847         local file=${2}
 848
 849         fread "${SYS_CLASS_NET}/${device}/${file}"
 850 }
 851
 852 __device_set_file() {
 853         assert [ $# -eq 3 ]
 854
 855         local device="${1}"
 856         local file="${2}"
 857         local value="${3}"
 858
 859         fappend "${SYS_CLASS_NET}/${device}/${file}" "${value}"
 860 }
 861
 862 device_get_rx_bytes() {
 863         local device=${1}
 864
 865         __device_get_file ${device} statistics/rx_bytes
 866 }
 867
 868 device_get_tx_bytes() {
 869         local device=${1}
 870
 871         __device_get_file ${device} statistics/tx_bytes
 872 }
 873
 874 device_get_rx_packets() {
 875         local device=${1}
 876
 877         __device_get_file ${device} statistics/rx_packets
 878 }
 879
 880 device_get_tx_packets() {
 881         local device=${1}
 882
 883         __device_get_file ${device} statistics/tx_packets
 884 }
 885
 886 device_get_rx_errors() {
 887         local device=${1}
 888
 889         __device_get_file ${device} statistics/rx_errors
 890 }
 891
 892 device_get_tx_errors() {
 893         local device=${1}
 894
 895         __device_get_file ${device} statistics/tx_errors
 896 }
 897
 898 device_advertise_link_speeds() {
 899         local device="${1}"
 900         shift
 901
 902         assert isset device
 903
 904         # Advertised modes in hex
 905         local advertise=0
 906
 907         local mode
 908         for mode in $@; do
 909                 local m="${DEVICE_LINK_SPEEDS[${mode}]}"
 910                 if isset m; then
 911                         advertise="$(( advertise | m ))"
 912                 fi
 913         done
 914
 915         # If nothing was selected, we reset and enable everything
 916         if [ ${advertise} -eq 0 ]; then
 917                 advertise=0xffffff
 918         fi
 919
 920         # Enable auto-negotiation
 921         cmd_quiet ethtool --change "${device}" autoneg on
 922
 923         # Set advertised link speeds
 924         if ! cmd_quiet ethtool --change "${device}" advertise "0x$(hex "${advertise}")"; then
 925                 log ERROR "Could not set link modes of ${device}: $@"
 926                 return ${EXIT_ERROR}
 927         fi
 928
 929         log DEBUG "Set device link modes of ${device} to $@"
 930         return ${EXIT_ERROR}
 931 }
 932
 933 device_get_speed() {
 934         local device=${1}
 935
 936         local speed=$(__device_get_file ${device} speed)
 937
 938         # Exit for no output (i.e. no link detected)
 939         isset speed || return ${EXIT_ERROR}
 940
 941         # Don't return anything for negative values
 942         [ ${speed} -lt 0 ] && return ${EXIT_ERROR}
 943
 944         print "${speed}"
 945 }
 946
 947 device_get_duplex() {
 948         local device=${1}
 949
 950         local duplex=$(__device_get_file ${device} duplex)
 951
 952         case "${duplex}" in
 953                 unknown)
 954                         return ${EXIT_ERROR}
 955                         ;;
 956                 *)
 957                         print "${duplex}"
 958                         ;;
 959         esac
 960 }
 961
 962 device_get_link_string() {
 963         local device="${1}"
 964         assert isset device
 965
 966         local s
 967
 968         local speed="$(device_get_speed "${device}")"
 969         if isset speed; then
 970                 list_append s "${speed} MBit/s"
 971         fi
 972
 973         local duplex="$(device_get_duplex "${device}")"
 974         if isset duplex; then
 975                 list_append s "${duplex} duplex"
 976         fi
 977
 978         print "${s}"
 979 }
 980
 981 device_auto_configure_smp_affinity() {
 982         assert [ $# -eq 1 ]
 983
 984         local device=${1}
 985
 986         if lock_acquire "smp-affinity" 60; then
 987                 device_set_smp_affinity ${device} auto
 988
 989                 lock_release "smp-affinity"
 990         fi
 991 }
 992
 993 device_set_smp_affinity() {
 994         assert [ $# -eq 2 ]
 995
 996         local device=${1}
 997         local mode=${2}
 998
 999         # mode can be auto which will automatically try to find
1000         # the least busy processor, or an integer for the desired
1001         # processor that should handle this device
1002
1003         local num_processors=$(system_get_processors)
1004
1005         if [ "${mode}" = "auto" ]; then
1006                 local processor=$(interrupt_choose_least_busy_processor)
1007         else
1008                 assert isinteger mode
1009                 local processor=${mode}
1010
1011                 if [ ${processor} -gt ${num_processors} ]; then
1012                         log ERROR "Processor ${processor} does not exist"
1013                         return ${EXIT_ERROR}
1014                 fi
1015         fi
1016
1017         local interrupts=$(interrupts_for_device ${device})
1018         if ! isset interrupts; then
1019                 log DEBUG "${device} has no interrupts. Not changing SMP affinity"
1020                 return ${EXIT_OK}
1021         fi
1022
1023         # Set SMP affinity
1024         local interrupt
1025         for interrupt in ${interrupts}; do
1026                 interrupt_set_smp_affinity ${interrupt} ${processor}
1027         done
1028
1029         # Find all queues and assign them to the next processor
1030         local queue
1031         for queue in $(device_get_queues ${device}); do
1032                 case "${queue}" in
1033                         # Only handle receive queues
1034                         rx-*)
1035                                 for interrupt in $(interrupts_for_device_queue ${device} ${queue}); do
1036                                         interrupt_set_smp_affinity ${interrupt} ${processor}
1037                                 done
1038
1039                                 device_queue_set_smp_affinity ${device} ${queue} ${processor}
1040                                 ;;
1041
1042                         # Ignore the rest
1043                         *)
1044                                 continue
1045                                 ;;
1046                 esac
1047
1048                 # Get the next available processor if in auto mode
1049                 [ "${mode}" = "auto" ] && processor=$(system_get_next_processor ${processor})
1050         done
1051
1052         return ${EXIT_OK}
1053 }
1054
1055 device_get_queues() {
1056         assert [ $# -eq 1 ]
1057
1058         local device=${1}
1059
1060         list_directory "${SYS_CLASS_NET}/${device}/queues"
1061 }
1062
1063 device_supports_multiqueue() {
1064         local device=${1}
1065
1066         local num_queues=$(device_num_queues ${device})
1067
1068         if isset num_queues && [ ${num_queues} -gt 2 ]; then
1069                 return ${EXIT_TRUE}
1070         fi
1071
1072         return ${EXIT_FALSE}
1073 }
1074
1075 device_num_queues() {
1076         local device=${1}
1077         local type=${2}
1078
1079         isset type && assert isoneof type rx tx
1080
1081         local i=0
1082
1083         local q
1084         for q in $(device_get_queues ${device}); do
1085                 case "${type},${q}" in
1086                         rx,rx-*)
1087                                 (( i++ ))
1088                                 ;;
1089                         tx,tx-*)
1090                                 (( i++ ))
1091                                 ;;
1092                         *,*)
1093                                 (( i++ ))
1094                                 ;;
1095                 esac
1096         done
1097
1098         print ${i}
1099 }
1100
1101 device_queue_get_smp_affinity() {
1102         assert [ $# -eq 2 ]
1103
1104         local device=${1}
1105         local queue=${2}
1106
1107         local path="${SYS_CLASS_NET}/${device}/queues/${queue}"
1108
1109         case "${queue}" in
1110                 rx-*)
1111                         path="${path}/rps_cpus"
1112                         ;;
1113                 tx-*)
1114                         path="${path}/xps_cpus"
1115                         ;;
1116         esac
1117         assert [ -r "${path}" ]
1118
1119         __bitmap_to_processor_ids $(<${path})
1120 }
1121
1122 device_queue_set_smp_affinity() {
1123         assert [ $# -eq 3 ]
1124
1125         local device=${1}
1126         local queue=${2}
1127         local processor=${3}
1128
1129         local path="${SYS_CLASS_NET}/${device}/queues/${queue}/rps_cpus"
1130         assert [ -w "${path}" ]
1131
1132         log DEBUG "Setting SMP affinity of ${device} (${queue}) to processor ${processor}"
1133
1134         __processor_id_to_bitmap ${processor} > ${path}
1135 }
1136
1137 # Tries to find a device which has the given IP address assigned
1138 device_get_by_assigned_ip_address() {
1139         local ip=${1}
1140
1141         assert isset ip
1142
1143         local device
1144
1145         # Read the first line of ip addr show to
1146         read -r device <<< $(ip addr show to "${ip}")
1147
1148         # If we did not found a device we return with ${EXIT_ERROR}
1149         if ! isset device; then
1150                 return ${EXIT_ERROR}
1151         fi
1152
1153         # We get something like:
1154         # 3: upl0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
1155         # and we want upl0 so we take the second word and removing the :
1156         device=(${device})
1157         device=${device[1]}
1158         device=${device%:}
1159
1160         print "${device}"
1161         return ${EXIT_OK}
1162 }
1163
1164 device_get_by_mac_address() {
1165         local mac=${1}
1166
1167         assert isset mac
1168
1169         local device
1170
1171         for device in $(device_list); do
1172                 if [ "${mac}" = "$(device_get_address ${device})" ]; then
1173                         print "${device}"
1174                         return ${EXIT_OK}
1175                 fi
1176         done
1177
1178         # We could not found a port to the given mac address so we return exit error
1179         return ${EXIT_ERROR}
1180 }