LCOV - code coverage report
Current view: top level - src/ap - acs.c (source / functions) Hit Total Coverage
Test: hostapd/hlr_auc_gw (AS) hwsim test run 1388338050 Lines: 0 284 0.0 %
Date: 2013-12-29 Functions: 0 20 0.0 %
Branches: 0 163 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * ACS - Automatic Channel Selection module
       3                 :            :  * Copyright (c) 2011, Atheros Communications
       4                 :            :  * Copyright (c) 2013, Qualcomm Atheros, Inc.
       5                 :            :  *
       6                 :            :  * This software may be distributed under the terms of the BSD license.
       7                 :            :  * See README for more details.
       8                 :            :  */
       9                 :            : 
      10                 :            : #include "utils/includes.h"
      11                 :            : #include <math.h>
      12                 :            : 
      13                 :            : #include "utils/common.h"
      14                 :            : #include "utils/list.h"
      15                 :            : #include "common/ieee802_11_defs.h"
      16                 :            : #include "common/wpa_ctrl.h"
      17                 :            : #include "drivers/driver.h"
      18                 :            : #include "hostapd.h"
      19                 :            : #include "ap_drv_ops.h"
      20                 :            : #include "ap_config.h"
      21                 :            : #include "hw_features.h"
      22                 :            : #include "acs.h"
      23                 :            : 
      24                 :            : /*
      25                 :            :  * Automatic Channel Selection
      26                 :            :  * ===========================
      27                 :            :  *
      28                 :            :  * More info at
      29                 :            :  * ------------
      30                 :            :  * http://wireless.kernel.org/en/users/Documentation/acs
      31                 :            :  *
      32                 :            :  * How to use
      33                 :            :  * ----------
      34                 :            :  * - make sure you have CONFIG_ACS=y in hostapd's .config
      35                 :            :  * - use channel=0 or channel=acs to enable ACS
      36                 :            :  *
      37                 :            :  * How does it work
      38                 :            :  * ----------------
      39                 :            :  * 1. passive scans are used to collect survey data
      40                 :            :  *    (it is assumed that scan trigger collection of survey data in driver)
      41                 :            :  * 2. interference factor is calculated for each channel
      42                 :            :  * 3. ideal channel is picked depending on channel width by using adjacent
      43                 :            :  *    channel interference factors
      44                 :            :  *
      45                 :            :  * Known limitations
      46                 :            :  * -----------------
      47                 :            :  * - Current implementation depends heavily on the amount of time willing to
      48                 :            :  *   spend gathering survey data during hostapd startup. Short traffic bursts
      49                 :            :  *   may be missed and a suboptimal channel may be picked.
      50                 :            :  * - Ideal channel may end up overlapping a channel with 40 MHz intolerant BSS
      51                 :            :  *
      52                 :            :  * Todo / Ideas
      53                 :            :  * ------------
      54                 :            :  * - implement other interference computation methods
      55                 :            :  *   - BSS/RSSI based
      56                 :            :  *   - spectral scan based
      57                 :            :  *   (should be possibly to hook this up with current ACS scans)
      58                 :            :  * - add wpa_supplicant support (for P2P)
      59                 :            :  * - collect a histogram of interference over time allowing more educated
      60                 :            :  *   guess about an ideal channel (perhaps CSA could be used to migrate AP to a
      61                 :            :  *   new "better" channel while running)
      62                 :            :  * - include neighboring BSS scan to avoid conflicts with 40 MHz intolerant BSSs
      63                 :            :  *   when choosing the ideal channel
      64                 :            :  *
      65                 :            :  * Survey interference factor implementation details
      66                 :            :  * -------------------------------------------------
      67                 :            :  * Generic interference_factor in struct hostapd_channel_data is used.
      68                 :            :  *
      69                 :            :  * The survey interference factor is defined as the ratio of the
      70                 :            :  * observed busy time over the time we spent on the channel,
      71                 :            :  * this value is then amplified by the observed noise floor on
      72                 :            :  * the channel in comparison to the lowest noise floor observed
      73                 :            :  * on the entire band.
      74                 :            :  *
      75                 :            :  * This corresponds to:
      76                 :            :  * ---
      77                 :            :  * (busy time - tx time) / (active time - tx time) * 2^(chan_nf + band_min_nf)
      78                 :            :  * ---
      79                 :            :  *
      80                 :            :  * The coefficient of 2 reflects the way power in "far-field"
      81                 :            :  * radiation decreases as the square of distance from the antenna [1].
      82                 :            :  * What this does is it decreases the observed busy time ratio if the
      83                 :            :  * noise observed was low but increases it if the noise was high,
      84                 :            :  * proportionally to the way "far field" radiation changes over
      85                 :            :  * distance.
      86                 :            :  *
      87                 :            :  * If channel busy time is not available the fallback is to use channel RX time.
      88                 :            :  *
      89                 :            :  * Since noise floor is in dBm it is necessary to convert it into Watts so that
      90                 :            :  * combined channel interference (e.g., HT40, which uses two channels) can be
      91                 :            :  * calculated easily.
      92                 :            :  * ---
      93                 :            :  * (busy time - tx time) / (active time - tx time) *
      94                 :            :  *    2^(10^(chan_nf/10) + 10^(band_min_nf/10))
      95                 :            :  * ---
      96                 :            :  *
      97                 :            :  * However to account for cases where busy/rx time is 0 (channel load is then
      98                 :            :  * 0%) channel noise floor signal power is combined into the equation so a
      99                 :            :  * channel with lower noise floor is preferred. The equation becomes:
     100                 :            :  * ---
     101                 :            :  * 10^(chan_nf/5) + (busy time - tx time) / (active time - tx time) *
     102                 :            :  *    2^(10^(chan_nf/10) + 10^(band_min_nf/10))
     103                 :            :  * ---
     104                 :            :  *
     105                 :            :  * All this "interference factor" is purely subjective and only time
     106                 :            :  * will tell how usable this is. By using the minimum noise floor we
     107                 :            :  * remove any possible issues due to card calibration. The computation
     108                 :            :  * of the interference factor then is dependent on what the card itself
     109                 :            :  * picks up as the minimum noise, not an actual real possible card
     110                 :            :  * noise value.
     111                 :            :  *
     112                 :            :  * Total interference computation details
     113                 :            :  * --------------------------------------
     114                 :            :  * The above channel interference factor is calculated with no respect to
     115                 :            :  * target operational bandwidth.
     116                 :            :  *
     117                 :            :  * To find an ideal channel the above data is combined by taking into account
     118                 :            :  * the target operational bandwidth and selected band. E.g., on 2.4 GHz channels
     119                 :            :  * overlap with 20 MHz bandwidth, but there is no overlap for 20 MHz bandwidth
     120                 :            :  * on 5 GHz.
     121                 :            :  *
     122                 :            :  * Each valid and possible channel spec (i.e., channel + width) is taken and its
     123                 :            :  * interference factor is computed by summing up interferences of each channel
     124                 :            :  * it overlaps. The one with least total interference is picked up.
     125                 :            :  *
     126                 :            :  * Note: This implies base channel interference factor must be non-negative
     127                 :            :  * allowing easy summing up.
     128                 :            :  *
     129                 :            :  * Example ACS analysis printout
     130                 :            :  * -----------------------------
     131                 :            :  *
     132                 :            :  * ACS: Trying survey-based ACS
     133                 :            :  * ACS: Survey analysis for channel 1 (2412 MHz)
     134                 :            :  * ACS:  1: min_nf=-113 interference_factor=0.0802469 nf=-113 time=162 busy=0 rx=13
     135                 :            :  * ACS:  2: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
     136                 :            :  * ACS:  3: min_nf=-113 interference_factor=0.0679012 nf=-113 time=162 busy=0 rx=11
     137                 :            :  * ACS:  4: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
     138                 :            :  * ACS:  5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
     139                 :            :  * ACS:  * interference factor average: 0.0557166
     140                 :            :  * ACS: Survey analysis for channel 2 (2417 MHz)
     141                 :            :  * ACS:  1: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
     142                 :            :  * ACS:  2: min_nf=-113 interference_factor=0.0246914 nf=-113 time=162 busy=0 rx=4
     143                 :            :  * ACS:  3: min_nf=-113 interference_factor=0.037037 nf=-113 time=162 busy=0 rx=6
     144                 :            :  * ACS:  4: min_nf=-113 interference_factor=0.149068 nf=-113 time=161 busy=0 rx=24
     145                 :            :  * ACS:  5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
     146                 :            :  * ACS:  * interference factor average: 0.050832
     147                 :            :  * ACS: Survey analysis for channel 3 (2422 MHz)
     148                 :            :  * ACS:  1: min_nf=-113 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
     149                 :            :  * ACS:  2: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
     150                 :            :  * ACS:  3: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
     151                 :            :  * ACS:  4: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
     152                 :            :  * ACS:  5: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
     153                 :            :  * ACS:  * interference factor average: 0.0148838
     154                 :            :  * ACS: Survey analysis for channel 4 (2427 MHz)
     155                 :            :  * ACS:  1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     156                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
     157                 :            :  * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
     158                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
     159                 :            :  * ACS:  5: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
     160                 :            :  * ACS:  * interference factor average: 0.0160801
     161                 :            :  * ACS: Survey analysis for channel 5 (2432 MHz)
     162                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.409938 nf=-113 time=161 busy=0 rx=66
     163                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.0432099 nf=-113 time=162 busy=0 rx=7
     164                 :            :  * ACS:  3: min_nf=-114 interference_factor=0.0124224 nf=-113 time=161 busy=0 rx=2
     165                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.677019 nf=-113 time=161 busy=0 rx=109
     166                 :            :  * ACS:  5: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
     167                 :            :  * ACS:  * interference factor average: 0.232244
     168                 :            :  * ACS: Survey analysis for channel 6 (2437 MHz)
     169                 :            :  * ACS:  1: min_nf=-113 interference_factor=0.552795 nf=-113 time=161 busy=0 rx=89
     170                 :            :  * ACS:  2: min_nf=-113 interference_factor=0.0807453 nf=-112 time=161 busy=0 rx=13
     171                 :            :  * ACS:  3: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
     172                 :            :  * ACS:  4: min_nf=-113 interference_factor=0.434783 nf=-112 time=161 busy=0 rx=70
     173                 :            :  * ACS:  5: min_nf=-113 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
     174                 :            :  * ACS:  * interference factor average: 0.232298
     175                 :            :  * ACS: Survey analysis for channel 7 (2442 MHz)
     176                 :            :  * ACS:  1: min_nf=-113 interference_factor=0.440994 nf=-112 time=161 busy=0 rx=71
     177                 :            :  * ACS:  2: min_nf=-113 interference_factor=0.385093 nf=-113 time=161 busy=0 rx=62
     178                 :            :  * ACS:  3: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
     179                 :            :  * ACS:  4: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
     180                 :            :  * ACS:  5: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
     181                 :            :  * ACS:  * interference factor average: 0.195031
     182                 :            :  * ACS: Survey analysis for channel 8 (2447 MHz)
     183                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.0496894 nf=-112 time=161 busy=0 rx=8
     184                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.0496894 nf=-114 time=161 busy=0 rx=8
     185                 :            :  * ACS:  3: min_nf=-114 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
     186                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.12963 nf=-113 time=162 busy=0 rx=21
     187                 :            :  * ACS:  5: min_nf=-114 interference_factor=0.166667 nf=-114 time=162 busy=0 rx=27
     188                 :            :  * ACS:  * interference factor average: 0.0865885
     189                 :            :  * ACS: Survey analysis for channel 9 (2452 MHz)
     190                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.0124224 nf=-114 time=161 busy=0 rx=2
     191                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.0310559 nf=-114 time=161 busy=0 rx=5
     192                 :            :  * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
     193                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.00617284 nf=-114 time=162 busy=0 rx=1
     194                 :            :  * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     195                 :            :  * ACS:  * interference factor average: 0.00993022
     196                 :            :  * ACS: Survey analysis for channel 10 (2457 MHz)
     197                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
     198                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
     199                 :            :  * ACS:  3: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
     200                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.0493827 nf=-114 time=162 busy=0 rx=8
     201                 :            :  * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     202                 :            :  * ACS:  * interference factor average: 0.0136033
     203                 :            :  * ACS: Survey analysis for channel 11 (2462 MHz)
     204                 :            :  * ACS:  1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
     205                 :            :  * ACS:  2: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
     206                 :            :  * ACS:  3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
     207                 :            :  * ACS:  4: min_nf=-114 interference_factor=0.0432099 nf=-114 time=162 busy=0 rx=7
     208                 :            :  * ACS:  5: min_nf=-114 interference_factor=0.0925926 nf=-114 time=162 busy=0 rx=15
     209                 :            :  * ACS:  * interference factor average: 0.0271605
     210                 :            :  * ACS: Survey analysis for channel 12 (2467 MHz)
     211                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
     212                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
     213                 :            :  * ACS:  3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
     214                 :            :  * ACS:  4: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
     215                 :            :  * ACS:  5: min_nf=-114 interference_factor=0.00617284 nf=-113 time=162 busy=0 rx=1
     216                 :            :  * ACS:  * interference factor average: 0.0148992
     217                 :            :  * ACS: Survey analysis for channel 13 (2472 MHz)
     218                 :            :  * ACS:  1: min_nf=-114 interference_factor=0.0745342 nf=-114 time=161 busy=0 rx=12
     219                 :            :  * ACS:  2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
     220                 :            :  * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     221                 :            :  * ACS:  4: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     222                 :            :  * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
     223                 :            :  * ACS:  * interference factor average: 0.0260179
     224                 :            :  * ACS: Survey analysis for selected bandwidth 20MHz
     225                 :            :  * ACS:  * channel 1: total interference = 0.121432
     226                 :            :  * ACS:  * channel 2: total interference = 0.137512
     227                 :            :  * ACS:  * channel 3: total interference = 0.369757
     228                 :            :  * ACS:  * channel 4: total interference = 0.546338
     229                 :            :  * ACS:  * channel 5: total interference = 0.690538
     230                 :            :  * ACS:  * channel 6: total interference = 0.762242
     231                 :            :  * ACS:  * channel 7: total interference = 0.756092
     232                 :            :  * ACS:  * channel 8: total interference = 0.537451
     233                 :            :  * ACS:  * channel 9: total interference = 0.332313
     234                 :            :  * ACS:  * channel 10: total interference = 0.152182
     235                 :            :  * ACS:  * channel 11: total interference = 0.0916111
     236                 :            :  * ACS:  * channel 12: total interference = 0.0816809
     237                 :            :  * ACS:  * channel 13: total interference = 0.0680776
     238                 :            :  * ACS: Ideal channel is 13 (2472 MHz) with total interference factor of 0.0680776
     239                 :            :  *
     240                 :            :  * [1] http://en.wikipedia.org/wiki/Near_and_far_field
     241                 :            :  */
     242                 :            : 
     243                 :            : 
     244                 :            : static int acs_request_scan(struct hostapd_iface *iface);
     245                 :            : 
     246                 :            : 
     247                 :          0 : static void acs_clean_chan_surveys(struct hostapd_channel_data *chan)
     248                 :            : {
     249                 :            :         struct freq_survey *survey, *tmp;
     250                 :            : 
     251         [ #  # ]:          0 :         if (dl_list_empty(&chan->survey_list))
     252                 :          0 :                 return;
     253                 :            : 
     254         [ #  # ]:          0 :         dl_list_for_each_safe(survey, tmp, &chan->survey_list,
     255                 :            :                               struct freq_survey, list) {
     256                 :          0 :                 dl_list_del(&survey->list);
     257                 :          0 :                 os_free(survey);
     258                 :            :         }
     259                 :            : }
     260                 :            : 
     261                 :            : 
     262                 :          0 : static void acs_cleanup(struct hostapd_iface *iface)
     263                 :            : {
     264                 :            :         int i;
     265                 :            :         struct hostapd_channel_data *chan;
     266                 :            : 
     267         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     268                 :          0 :                 chan = &iface->current_mode->channels[i];
     269                 :            : 
     270         [ #  # ]:          0 :                 if (chan->flag & HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED)
     271                 :          0 :                         acs_clean_chan_surveys(chan);
     272                 :            : 
     273                 :          0 :                 dl_list_init(&chan->survey_list);
     274                 :          0 :                 chan->flag |= HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED;
     275                 :          0 :                 chan->min_nf = 0;
     276                 :            :         }
     277                 :            : 
     278                 :          0 :         iface->chans_surveyed = 0;
     279                 :          0 :         iface->acs_num_completed_scans = 0;
     280                 :          0 : }
     281                 :            : 
     282                 :            : 
     283                 :          0 : void acs_fail(struct hostapd_iface *iface)
     284                 :            : {
     285                 :          0 :         wpa_printf(MSG_ERROR, "ACS: Failed to start");
     286                 :          0 :         acs_cleanup(iface);
     287                 :          0 : }
     288                 :            : 
     289                 :            : 
     290                 :            : static long double
     291                 :          0 : acs_survey_interference_factor(struct freq_survey *survey, s8 min_nf)
     292                 :            : {
     293                 :            :         long double factor, busy, total;
     294                 :            : 
     295         [ #  # ]:          0 :         if (survey->filled & SURVEY_HAS_CHAN_TIME_BUSY)
     296                 :          0 :                 busy = survey->channel_time_busy;
     297         [ #  # ]:          0 :         else if (survey->filled & SURVEY_HAS_CHAN_TIME_RX)
     298                 :          0 :                 busy = survey->channel_time_rx;
     299                 :            :         else {
     300                 :            :                 /* This shouldn't really happen as survey data is checked in
     301                 :            :                  * acs_sanity_check() */
     302                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Survey data missing");
     303                 :          0 :                 return 0;
     304                 :            :         }
     305                 :            : 
     306                 :          0 :         total = survey->channel_time;
     307                 :            : 
     308         [ #  # ]:          0 :         if (survey->filled & SURVEY_HAS_CHAN_TIME_TX) {
     309                 :          0 :                 busy -= survey->channel_time_tx;
     310                 :          0 :                 total -= survey->channel_time_tx;
     311                 :            :         }
     312                 :            : 
     313                 :            :         /* TODO: figure out the best multiplier for noise floor base */
     314                 :          0 :         factor = pow(10, survey->nf / 5.0L) +
     315                 :          0 :                 (busy / total) *
     316                 :          0 :                 pow(2, pow(10, (long double) survey->nf / 10.0L) -
     317                 :          0 :                     pow(10, (long double) min_nf / 10.0L));
     318                 :            : 
     319                 :          0 :         return factor;
     320                 :            : }
     321                 :            : 
     322                 :            : 
     323                 :            : static void
     324                 :          0 : acs_survey_chan_interference_factor(struct hostapd_iface *iface,
     325                 :            :                                     struct hostapd_channel_data *chan)
     326                 :            : {
     327                 :            :         struct freq_survey *survey;
     328                 :          0 :         unsigned int i = 0;
     329                 :          0 :         long double int_factor = 0;
     330                 :            : 
     331         [ #  # ]:          0 :         if (dl_list_empty(&chan->survey_list))
     332                 :          0 :                 return;
     333                 :            : 
     334         [ #  # ]:          0 :         if (chan->flag & HOSTAPD_CHAN_DISABLED)
     335                 :          0 :                 return;
     336                 :            : 
     337                 :          0 :         chan->interference_factor = 0;
     338                 :            : 
     339         [ #  # ]:          0 :         dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
     340                 :            :         {
     341                 :          0 :                 int_factor = acs_survey_interference_factor(survey,
     342                 :          0 :                                                             iface->lowest_nf);
     343                 :          0 :                 chan->interference_factor += int_factor;
     344                 :          0 :                 wpa_printf(MSG_DEBUG, "ACS: %d: min_nf=%d interference_factor=%Lg nf=%d time=%lu busy=%lu rx=%lu",
     345                 :          0 :                            ++i, chan->min_nf, int_factor,
     346                 :          0 :                            survey->nf, (unsigned long) survey->channel_time,
     347                 :            :                            (unsigned long) survey->channel_time_busy,
     348                 :            :                            (unsigned long) survey->channel_time_rx);
     349                 :            :         }
     350                 :            : 
     351                 :          0 :         chan->interference_factor = chan->interference_factor /
     352                 :          0 :                 dl_list_len(&chan->survey_list);
     353                 :            : }
     354                 :            : 
     355                 :            : 
     356                 :          0 : static int acs_usable_ht40_chan(struct hostapd_channel_data *chan)
     357                 :            : {
     358                 :          0 :         const int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149,
     359                 :            :                                 157, 184, 192 };
     360                 :            :         unsigned int i;
     361                 :            : 
     362         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(allowed); i++)
     363         [ #  # ]:          0 :                 if (chan->chan == allowed[i])
     364                 :          0 :                         return 1;
     365                 :            : 
     366                 :          0 :         return 0;
     367                 :            : }
     368                 :            : 
     369                 :            : 
     370                 :          0 : static int acs_survey_is_sufficient(struct freq_survey *survey)
     371                 :            : {
     372         [ #  # ]:          0 :         if (!(survey->filled & SURVEY_HAS_NF)) {
     373                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Survey is missing noise floor");
     374                 :          0 :                 return 0;
     375                 :            :         }
     376                 :            : 
     377         [ #  # ]:          0 :         if (!(survey->filled & SURVEY_HAS_CHAN_TIME)) {
     378                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Survey is missing channel time");
     379                 :          0 :                 return 0;
     380                 :            :         }
     381                 :            : 
     382 [ #  # ][ #  # ]:          0 :         if (!(survey->filled & SURVEY_HAS_CHAN_TIME_BUSY) &&
     383                 :          0 :             !(survey->filled & SURVEY_HAS_CHAN_TIME_RX)) {
     384                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Survey is missing RX and busy time (at least one is required)");
     385                 :          0 :                 return 0;
     386                 :            :         }
     387                 :            : 
     388                 :          0 :         return 1;
     389                 :            : }
     390                 :            : 
     391                 :            : 
     392                 :          0 : static int acs_survey_list_is_sufficient(struct hostapd_channel_data *chan)
     393                 :            : {
     394                 :            :         struct freq_survey *survey;
     395                 :            : 
     396         [ #  # ]:          0 :         dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
     397                 :            :         {
     398         [ #  # ]:          0 :                 if (!acs_survey_is_sufficient(survey)) {
     399                 :          0 :                         wpa_printf(MSG_ERROR, "ACS: Channel %d has insufficient survey data",
     400                 :          0 :                                    chan->chan);
     401                 :          0 :                         return 0;
     402                 :            :                 }
     403                 :            :         }
     404                 :            : 
     405                 :          0 :         return 1;
     406                 :            : 
     407                 :            : }
     408                 :            : 
     409                 :            : 
     410                 :          0 : static int acs_surveys_are_sufficient(struct hostapd_iface *iface)
     411                 :            : {
     412                 :            :         int i;
     413                 :            :         struct hostapd_channel_data *chan;
     414                 :          0 :         int valid = 0;
     415                 :            : 
     416         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     417                 :          0 :                 chan = &iface->current_mode->channels[i];
     418         [ #  # ]:          0 :                 if (chan->flag & HOSTAPD_CHAN_DISABLED)
     419                 :          0 :                         continue;
     420                 :            : 
     421         [ #  # ]:          0 :                 if (!acs_survey_list_is_sufficient(chan))
     422                 :          0 :                         continue;
     423                 :            : 
     424                 :          0 :                 valid++;
     425                 :            :         }
     426                 :            : 
     427                 :            :         /* We need at least survey data for one channel */
     428                 :          0 :         return !!valid;
     429                 :            : }
     430                 :            : 
     431                 :            : 
     432                 :          0 : static int acs_usable_chan(struct hostapd_channel_data *chan)
     433                 :            : {
     434         [ #  # ]:          0 :         if (dl_list_empty(&chan->survey_list))
     435                 :          0 :                 return 0;
     436         [ #  # ]:          0 :         if (chan->flag & HOSTAPD_CHAN_DISABLED)
     437                 :          0 :                 return 0;
     438         [ #  # ]:          0 :         if (!acs_survey_list_is_sufficient(chan))
     439                 :          0 :                 return 0;
     440                 :          0 :         return 1;
     441                 :            : }
     442                 :            : 
     443                 :            : 
     444                 :          0 : static void acs_survey_all_chans_intereference_factor(
     445                 :            :         struct hostapd_iface *iface)
     446                 :            : {
     447                 :            :         int i;
     448                 :            :         struct hostapd_channel_data *chan;
     449                 :            : 
     450         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     451                 :          0 :                 chan = &iface->current_mode->channels[i];
     452                 :            : 
     453         [ #  # ]:          0 :                 if (!acs_usable_chan(chan))
     454                 :          0 :                         continue;
     455                 :            : 
     456                 :          0 :                 wpa_printf(MSG_DEBUG, "ACS: Survey analysis for channel %d (%d MHz)",
     457                 :          0 :                            chan->chan, chan->freq);
     458                 :            : 
     459                 :          0 :                 acs_survey_chan_interference_factor(iface, chan);
     460                 :            : 
     461                 :          0 :                 wpa_printf(MSG_DEBUG, "ACS:  * interference factor average: %Lg",
     462                 :            :                            chan->interference_factor);
     463                 :            :         }
     464                 :          0 : }
     465                 :            : 
     466                 :            : 
     467                 :          0 : static struct hostapd_channel_data *acs_find_chan(struct hostapd_iface *iface,
     468                 :            :                                                   int freq)
     469                 :            : {
     470                 :            :         struct hostapd_channel_data *chan;
     471                 :            :         int i;
     472                 :            : 
     473         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     474                 :          0 :                 chan = &iface->current_mode->channels[i];
     475                 :            : 
     476         [ #  # ]:          0 :                 if (chan->flag & HOSTAPD_CHAN_DISABLED)
     477                 :          0 :                         continue;
     478                 :            : 
     479         [ #  # ]:          0 :                 if (chan->freq == freq)
     480                 :          0 :                         return chan;
     481                 :            :         }
     482                 :            : 
     483                 :          0 :         return NULL;
     484                 :            : }
     485                 :            : 
     486                 :            : 
     487                 :            : /*
     488                 :            :  * At this point it's assumed chan->interface_factor has been computed.
     489                 :            :  * This function should be reusable regardless of interference computation
     490                 :            :  * option (survey, BSS, spectral, ...). chan->interference factor must be
     491                 :            :  * summable (i.e., must be always greater than zero).
     492                 :            :  */
     493                 :            : static struct hostapd_channel_data *
     494                 :          0 : acs_find_ideal_chan(struct hostapd_iface *iface)
     495                 :            : {
     496                 :          0 :         struct hostapd_channel_data *chan, *adj_chan, *ideal_chan = NULL,
     497                 :          0 :                 *rand_chan = NULL;
     498                 :          0 :         long double factor, ideal_factor = 0;
     499                 :            :         int i, j;
     500                 :          0 :         int n_chans = 1;
     501                 :            : 
     502                 :            :         /* TODO: HT40- support */
     503                 :            : 
     504 [ #  # ][ #  # ]:          0 :         if (iface->conf->ieee80211n &&
     505                 :          0 :             iface->conf->secondary_channel == -1) {
     506                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: HT40- is not supported yet. Please try HT40+");
     507                 :          0 :                 return NULL;
     508                 :            :         }
     509                 :            : 
     510 [ #  # ][ #  # ]:          0 :         if (iface->conf->ieee80211n &&
     511                 :          0 :             iface->conf->secondary_channel)
     512                 :          0 :                 n_chans = 2;
     513                 :            : 
     514 [ #  # ][ #  # ]:          0 :         if (iface->conf->ieee80211ac &&
     515                 :          0 :             iface->conf->vht_oper_chwidth == 1)
     516                 :          0 :                 n_chans = 4;
     517                 :            : 
     518                 :            :         /* TODO: VHT80+80, VHT160. Update acs_adjust_vht_center_freq() too. */
     519                 :            : 
     520         [ #  # ]:          0 :         wpa_printf(MSG_DEBUG, "ACS: Survey analysis for selected bandwidth %d MHz",
     521                 :            :                    n_chans == 1 ? 20 :
     522         [ #  # ]:          0 :                    n_chans == 2 ? 40 :
     523         [ #  # ]:          0 :                    n_chans == 4 ? 80 :
     524                 :            :                    -1);
     525                 :            : 
     526         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     527                 :          0 :                 chan = &iface->current_mode->channels[i];
     528                 :            : 
     529         [ #  # ]:          0 :                 if (chan->flag & HOSTAPD_CHAN_DISABLED)
     530                 :          0 :                         continue;
     531                 :            : 
     532                 :            : 
     533                 :            :                 /* HT40 on 5 GHz has a limited set of primary channels as per
     534                 :            :                  * 11n Annex J */
     535 [ #  # ][ #  # ]:          0 :                 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A &&
     536         [ #  # ]:          0 :                     iface->conf->ieee80211n &&
     537         [ #  # ]:          0 :                     iface->conf->secondary_channel &&
     538                 :          0 :                     !acs_usable_ht40_chan(chan)) {
     539                 :          0 :                         wpa_printf(MSG_DEBUG, "ACS: Channel %d: not allowed as primary channel for HT40",
     540                 :          0 :                                    chan->chan);
     541                 :          0 :                         continue;
     542                 :            :                 }
     543                 :            : 
     544                 :          0 :                 factor = 0;
     545         [ #  # ]:          0 :                 if (acs_usable_chan(chan))
     546                 :          0 :                         factor = chan->interference_factor;
     547                 :            : 
     548         [ #  # ]:          0 :                 for (j = 1; j < n_chans; j++) {
     549                 :          0 :                         adj_chan = acs_find_chan(iface, chan->freq + (j * 20));
     550         [ #  # ]:          0 :                         if (!adj_chan)
     551                 :          0 :                                 break;
     552                 :            : 
     553         [ #  # ]:          0 :                         if (acs_usable_chan(adj_chan))
     554                 :          0 :                                 factor += adj_chan->interference_factor;
     555                 :            :                 }
     556                 :            : 
     557         [ #  # ]:          0 :                 if (j != n_chans) {
     558                 :          0 :                         wpa_printf(MSG_DEBUG, "ACS: Channel %d: not enough bandwidth",
     559                 :          0 :                                    chan->chan);
     560                 :          0 :                         continue;
     561                 :            :                 }
     562                 :            : 
     563                 :            :                 /* 2.4 GHz has overlapping 20 MHz channels. Include adjacent
     564                 :            :                  * channel interference factor. */
     565 [ #  # ][ #  # ]:          0 :                 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211B ||
     566                 :          0 :                     iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G) {
     567         [ #  # ]:          0 :                         for (j = 0; j < n_chans; j++) {
     568                 :            :                                 /* TODO: perhaps a multiplier should be used
     569                 :            :                                  * here? */
     570                 :            : 
     571                 :          0 :                                 adj_chan = acs_find_chan(iface, chan->freq +
     572                 :          0 :                                                          (j * 20) - 5);
     573 [ #  # ][ #  # ]:          0 :                                 if (adj_chan && acs_usable_chan(adj_chan))
     574                 :          0 :                                         factor += adj_chan->interference_factor;
     575                 :            : 
     576                 :          0 :                                 adj_chan = acs_find_chan(iface, chan->freq +
     577                 :          0 :                                                          (j * 20) - 10);
     578 [ #  # ][ #  # ]:          0 :                                 if (adj_chan && acs_usable_chan(adj_chan))
     579                 :          0 :                                         factor += adj_chan->interference_factor;
     580                 :            : 
     581                 :          0 :                                 adj_chan = acs_find_chan(iface, chan->freq +
     582                 :          0 :                                                          (j * 20) + 5);
     583 [ #  # ][ #  # ]:          0 :                                 if (adj_chan && acs_usable_chan(adj_chan))
     584                 :          0 :                                         factor += adj_chan->interference_factor;
     585                 :            : 
     586                 :          0 :                                 adj_chan = acs_find_chan(iface, chan->freq +
     587                 :          0 :                                                          (j * 20) + 10);
     588 [ #  # ][ #  # ]:          0 :                                 if (adj_chan && acs_usable_chan(adj_chan))
     589                 :          0 :                                         factor += adj_chan->interference_factor;
     590                 :            :                         }
     591                 :            :                 }
     592                 :            : 
     593                 :          0 :                 wpa_printf(MSG_DEBUG, "ACS:  * channel %d: total interference = %Lg",
     594                 :          0 :                            chan->chan, factor);
     595                 :            : 
     596 [ #  # ][ #  # ]:          0 :                 if (acs_usable_chan(chan) &&
     597         [ #  # ]:          0 :                     (!ideal_chan || factor < ideal_factor)) {
     598                 :          0 :                         ideal_factor = factor;
     599                 :          0 :                         ideal_chan = chan;
     600                 :            :                 }
     601                 :            : 
     602                 :            :                 /* This channel would at least be usable */
     603         [ #  # ]:          0 :                 if (!rand_chan)
     604                 :          0 :                         rand_chan = chan;
     605                 :            :         }
     606                 :            : 
     607         [ #  # ]:          0 :         if (ideal_chan) {
     608                 :          0 :                 wpa_printf(MSG_DEBUG, "ACS: Ideal channel is %d (%d MHz) with total interference factor of %Lg",
     609                 :          0 :                            ideal_chan->chan, ideal_chan->freq, ideal_factor);
     610                 :          0 :                 return ideal_chan;
     611                 :            :         }
     612                 :            : 
     613                 :          0 :         return rand_chan;
     614                 :            : }
     615                 :            : 
     616                 :            : 
     617                 :          0 : static void acs_adjust_vht_center_freq(struct hostapd_iface *iface)
     618                 :            : {
     619                 :          0 :         wpa_printf(MSG_DEBUG, "ACS: Adjusting VHT center frequency");
     620                 :            : 
     621      [ #  #  # ]:          0 :         switch (iface->conf->vht_oper_chwidth) {
     622                 :            :         case VHT_CHANWIDTH_USE_HT:
     623                 :          0 :                 iface->conf->vht_oper_centr_freq_seg0_idx =
     624                 :          0 :                         iface->conf->channel + 2;
     625                 :          0 :                 break;
     626                 :            :         case VHT_CHANWIDTH_80MHZ:
     627                 :          0 :                 iface->conf->vht_oper_centr_freq_seg0_idx =
     628                 :          0 :                         iface->conf->channel + 6;
     629                 :          0 :                 break;
     630                 :            :         default:
     631                 :            :                 /* TODO: How can this be calculated? Adjust
     632                 :            :                  * acs_find_ideal_chan() */
     633                 :          0 :                 wpa_printf(MSG_INFO, "ACS: Only VHT20/40/80 is supported now");
     634                 :          0 :                 break;
     635                 :            :         }
     636                 :          0 : }
     637                 :            : 
     638                 :            : 
     639                 :          0 : static int acs_study_survey_based(struct hostapd_iface *iface)
     640                 :            : {
     641                 :          0 :         wpa_printf(MSG_DEBUG, "ACS: Trying survey-based ACS");
     642                 :            : 
     643         [ #  # ]:          0 :         if (!iface->chans_surveyed) {
     644                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Unable to collect survey data");
     645                 :          0 :                 return -1;
     646                 :            :         }
     647                 :            : 
     648         [ #  # ]:          0 :         if (!acs_surveys_are_sufficient(iface)) {
     649                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Surveys have insufficient data");
     650                 :          0 :                 return -1;
     651                 :            :         }
     652                 :            : 
     653                 :          0 :         acs_survey_all_chans_intereference_factor(iface);
     654                 :          0 :         return 0;
     655                 :            : }
     656                 :            : 
     657                 :            : 
     658                 :          0 : static int acs_study_options(struct hostapd_iface *iface)
     659                 :            : {
     660                 :            :         int err;
     661                 :            : 
     662                 :          0 :         err = acs_study_survey_based(iface);
     663         [ #  # ]:          0 :         if (err == 0)
     664                 :          0 :                 return 0;
     665                 :            : 
     666                 :            :         /* TODO: If no surveys are available/sufficient this is a good
     667                 :            :          * place to fallback to BSS-based ACS */
     668                 :            : 
     669                 :          0 :         return -1;
     670                 :            : }
     671                 :            : 
     672                 :            : 
     673                 :          0 : static void acs_study(struct hostapd_iface *iface)
     674                 :            : {
     675                 :            :         struct hostapd_channel_data *ideal_chan;
     676                 :            :         int err;
     677                 :            : 
     678                 :          0 :         err = acs_study_options(iface);
     679         [ #  # ]:          0 :         if (err < 0) {
     680                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: All study options have failed");
     681                 :          0 :                 goto fail;
     682                 :            :         }
     683                 :            : 
     684                 :          0 :         ideal_chan = acs_find_ideal_chan(iface);
     685         [ #  # ]:          0 :         if (!ideal_chan) {
     686                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Failed to compute ideal channel");
     687                 :          0 :                 err = -1;
     688                 :          0 :                 goto fail;
     689                 :            :         }
     690                 :            : 
     691                 :          0 :         iface->conf->channel = ideal_chan->chan;
     692                 :            : 
     693         [ #  # ]:          0 :         if (iface->conf->ieee80211ac)
     694                 :          0 :                 acs_adjust_vht_center_freq(iface);
     695                 :            : 
     696                 :          0 :         err = 0;
     697                 :            : fail:
     698                 :            :         /*
     699                 :            :          * hostapd_setup_interface_complete() will return -1 on failure,
     700                 :            :          * 0 on success and 0 is HOSTAPD_CHAN_VALID :)
     701                 :            :          */
     702         [ #  # ]:          0 :         if (hostapd_acs_completed(iface, err) == HOSTAPD_CHAN_VALID) {
     703                 :          0 :                 acs_cleanup(iface);
     704                 :          0 :                 return;
     705                 :            :         }
     706                 :            : 
     707                 :            :         /* This can possibly happen if channel parameters (secondary
     708                 :            :          * channel, center frequencies) are misconfigured */
     709                 :          0 :         wpa_printf(MSG_ERROR, "ACS: Possibly channel configuration is invalid, please report this along with your config file.");
     710                 :          0 :         acs_fail(iface);
     711                 :            : }
     712                 :            : 
     713                 :            : 
     714                 :          0 : static void acs_scan_complete(struct hostapd_iface *iface)
     715                 :            : {
     716                 :            :         int err;
     717                 :            : 
     718                 :          0 :         iface->scan_cb = NULL;
     719                 :            : 
     720                 :          0 :         wpa_printf(MSG_DEBUG, "ACS: Using survey based algorithm (acs_num_scans=%d)",
     721                 :          0 :                    iface->conf->acs_num_scans);
     722                 :            : 
     723                 :          0 :         err = hostapd_drv_get_survey(iface->bss[0], 0);
     724         [ #  # ]:          0 :         if (err) {
     725                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Failed to get survey data");
     726                 :          0 :                 acs_fail(iface);
     727                 :            :         }
     728                 :            : 
     729         [ #  # ]:          0 :         if (++iface->acs_num_completed_scans < iface->conf->acs_num_scans) {
     730                 :          0 :                 err = acs_request_scan(iface);
     731         [ #  # ]:          0 :                 if (err) {
     732                 :          0 :                         wpa_printf(MSG_ERROR, "ACS: Failed to request scan");
     733                 :          0 :                         goto fail;
     734                 :            :                 }
     735                 :            : 
     736                 :          0 :                 return;
     737                 :            :         }
     738                 :            : 
     739                 :          0 :         acs_study(iface);
     740                 :          0 :         return;
     741                 :            : fail:
     742                 :          0 :         hostapd_acs_completed(iface, 1);
     743                 :          0 :         acs_fail(iface);
     744                 :            : }
     745                 :            : 
     746                 :            : 
     747                 :          0 : static int acs_request_scan(struct hostapd_iface *iface)
     748                 :            : {
     749                 :            :         struct wpa_driver_scan_params params;
     750                 :            :         struct hostapd_channel_data *chan;
     751                 :            :         int i, *freq;
     752                 :            : 
     753                 :          0 :         os_memset(&params, 0, sizeof(params));
     754                 :          0 :         params.freqs = os_calloc(iface->current_mode->num_channels + 1,
     755                 :            :                                  sizeof(params.freqs[0]));
     756         [ #  # ]:          0 :         if (params.freqs == NULL)
     757                 :          0 :                 return -1;
     758                 :            : 
     759                 :          0 :         freq = params.freqs;
     760         [ #  # ]:          0 :         for (i = 0; i < iface->current_mode->num_channels; i++) {
     761                 :          0 :                 chan = &iface->current_mode->channels[i];
     762         [ #  # ]:          0 :                 if (chan->flag & HOSTAPD_CHAN_DISABLED)
     763                 :          0 :                         continue;
     764                 :            : 
     765                 :          0 :                 *freq++ = chan->freq;
     766                 :            :         }
     767                 :          0 :         *freq = 0;
     768                 :            : 
     769                 :          0 :         iface->scan_cb = acs_scan_complete;
     770                 :            : 
     771                 :          0 :         wpa_printf(MSG_DEBUG, "ACS: Scanning %d / %d",
     772                 :          0 :                    iface->acs_num_completed_scans + 1,
     773                 :          0 :                    iface->conf->acs_num_scans);
     774                 :            : 
     775         [ #  # ]:          0 :         if (hostapd_driver_scan(iface->bss[0], &params) < 0) {
     776                 :          0 :                 wpa_printf(MSG_ERROR, "ACS: Failed to request initial scan");
     777                 :          0 :                 acs_cleanup(iface);
     778                 :          0 :                 return -1;
     779                 :            :         }
     780                 :            : 
     781                 :          0 :         os_free(params.freqs);
     782                 :          0 :         return 0;
     783                 :            : }
     784                 :            : 
     785                 :            : 
     786                 :          0 : enum hostapd_chan_status acs_init(struct hostapd_iface *iface)
     787                 :            : {
     788                 :            :         int err;
     789                 :            : 
     790                 :          0 :         wpa_printf(MSG_INFO, "ACS: Automatic channel selection started, this may take a bit");
     791                 :            : 
     792                 :          0 :         acs_cleanup(iface);
     793                 :            : 
     794                 :          0 :         err = acs_request_scan(iface);
     795         [ #  # ]:          0 :         if (err < 0)
     796                 :          0 :                 return HOSTAPD_CHAN_INVALID;
     797                 :            : 
     798                 :          0 :         hostapd_set_state(iface, HAPD_IFACE_ACS);
     799                 :          0 :         wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_STARTED);
     800                 :            : 
     801                 :          0 :         return HOSTAPD_CHAN_ACS;
     802                 :            : }

Generated by: LCOV version 1.9