lkml.org 
[lkml]   [2020]   [Oct]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.9 057/757] net: openvswitch: fix to make sure flow_lookup() is not preempted
    Date
    From: Eelco Chaudron <echaudro@redhat.com>

    [ Upstream commit f981fc3d515a588c389242b7e3a71487b40571a5 ]

    The flow_lookup() function uses per CPU variables, which must be called
    with BH disabled. However, this is fine in the general NAPI use case
    where the local BH is disabled. But, it's also called from the netlink
    context. The below patch makes sure that even in the netlink path, the
    BH is disabled.

    In addition, u64_stats_update_begin() requires a lock to ensure one writer
    which is not ensured here. Making it per-CPU and disabling NAPI (softirq)
    ensures that there is always only one writer.

    Fixes: eac87c413bf9 ("net: openvswitch: reorder masks array based on usage")
    Reported-by: Juri Lelli <jlelli@redhat.com>
    Signed-off-by: Eelco Chaudron <echaudro@redhat.com>
    Link: https://lore.kernel.org/r/160295903253.7789.826736662555102345.stgit@ebuild
    Signed-off-by: Jakub Kicinski <kuba@kernel.org>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    net/openvswitch/flow_table.c | 58 +++++++++++++++++++++++++------------------
    net/openvswitch/flow_table.h | 8 ++++-
    2 files changed, 41 insertions(+), 25 deletions(-)

    --- a/net/openvswitch/flow_table.c
    +++ b/net/openvswitch/flow_table.c
    @@ -172,7 +172,7 @@ static struct table_instance *table_inst

    static void __mask_array_destroy(struct mask_array *ma)
    {
    - free_percpu(ma->masks_usage_cntr);
    + free_percpu(ma->masks_usage_stats);
    kfree(ma);
    }

    @@ -196,15 +196,15 @@ static void tbl_mask_array_reset_counter
    ma->masks_usage_zero_cntr[i] = 0;

    for_each_possible_cpu(cpu) {
    - u64 *usage_counters = per_cpu_ptr(ma->masks_usage_cntr,
    - cpu);
    + struct mask_array_stats *stats;
    unsigned int start;
    u64 counter;

    + stats = per_cpu_ptr(ma->masks_usage_stats, cpu);
    do {
    - start = u64_stats_fetch_begin_irq(&ma->syncp);
    - counter = usage_counters[i];
    - } while (u64_stats_fetch_retry_irq(&ma->syncp, start));
    + start = u64_stats_fetch_begin_irq(&stats->syncp);
    + counter = stats->usage_cntrs[i];
    + } while (u64_stats_fetch_retry_irq(&stats->syncp, start));

    ma->masks_usage_zero_cntr[i] += counter;
    }
    @@ -227,9 +227,10 @@ static struct mask_array *tbl_mask_array
    sizeof(struct sw_flow_mask *) *
    size);

    - new->masks_usage_cntr = __alloc_percpu(sizeof(u64) * size,
    - __alignof__(u64));
    - if (!new->masks_usage_cntr) {
    + new->masks_usage_stats = __alloc_percpu(sizeof(struct mask_array_stats) +
    + sizeof(u64) * size,
    + __alignof__(u64));
    + if (!new->masks_usage_stats) {
    kfree(new);
    return NULL;
    }
    @@ -723,6 +724,8 @@ static struct sw_flow *masked_flow_looku

    /* Flow lookup does full lookup on flow table. It starts with
    * mask from index passed in *index.
    + * This function MUST be called with BH disabled due to the use
    + * of CPU specific variables.
    */
    static struct sw_flow *flow_lookup(struct flow_table *tbl,
    struct table_instance *ti,
    @@ -732,7 +735,7 @@ static struct sw_flow *flow_lookup(struc
    u32 *n_cache_hit,
    u32 *index)
    {
    - u64 *usage_counters = this_cpu_ptr(ma->masks_usage_cntr);
    + struct mask_array_stats *stats = this_cpu_ptr(ma->masks_usage_stats);
    struct sw_flow *flow;
    struct sw_flow_mask *mask;
    int i;
    @@ -742,9 +745,9 @@ static struct sw_flow *flow_lookup(struc
    if (mask) {
    flow = masked_flow_lookup(ti, key, mask, n_mask_hit);
    if (flow) {
    - u64_stats_update_begin(&ma->syncp);
    - usage_counters[*index]++;
    - u64_stats_update_end(&ma->syncp);
    + u64_stats_update_begin(&stats->syncp);
    + stats->usage_cntrs[*index]++;
    + u64_stats_update_end(&stats->syncp);
    (*n_cache_hit)++;
    return flow;
    }
    @@ -763,9 +766,9 @@ static struct sw_flow *flow_lookup(struc
    flow = masked_flow_lookup(ti, key, mask, n_mask_hit);
    if (flow) { /* Found */
    *index = i;
    - u64_stats_update_begin(&ma->syncp);
    - usage_counters[*index]++;
    - u64_stats_update_end(&ma->syncp);
    + u64_stats_update_begin(&stats->syncp);
    + stats->usage_cntrs[*index]++;
    + u64_stats_update_end(&stats->syncp);
    return flow;
    }
    }
    @@ -851,9 +854,17 @@ struct sw_flow *ovs_flow_tbl_lookup(stru
    struct mask_array *ma = rcu_dereference_ovsl(tbl->mask_array);
    u32 __always_unused n_mask_hit;
    u32 __always_unused n_cache_hit;
    + struct sw_flow *flow;
    u32 index = 0;

    - return flow_lookup(tbl, ti, ma, key, &n_mask_hit, &n_cache_hit, &index);
    + /* This function gets called trough the netlink interface and therefore
    + * is preemptible. However, flow_lookup() function needs to be called
    + * with BH disabled due to CPU specific variables.
    + */
    + local_bh_disable();
    + flow = flow_lookup(tbl, ti, ma, key, &n_mask_hit, &n_cache_hit, &index);
    + local_bh_enable();
    + return flow;
    }

    struct sw_flow *ovs_flow_tbl_lookup_exact(struct flow_table *tbl,
    @@ -1109,7 +1120,6 @@ void ovs_flow_masks_rebalance(struct flo

    for (i = 0; i < ma->max; i++) {
    struct sw_flow_mask *mask;
    - unsigned int start;
    int cpu;

    mask = rcu_dereference_ovsl(ma->masks[i]);
    @@ -1120,14 +1130,16 @@ void ovs_flow_masks_rebalance(struct flo
    masks_and_count[i].counter = 0;

    for_each_possible_cpu(cpu) {
    - u64 *usage_counters = per_cpu_ptr(ma->masks_usage_cntr,
    - cpu);
    + struct mask_array_stats *stats;
    + unsigned int start;
    u64 counter;

    + stats = per_cpu_ptr(ma->masks_usage_stats, cpu);
    do {
    - start = u64_stats_fetch_begin_irq(&ma->syncp);
    - counter = usage_counters[i];
    - } while (u64_stats_fetch_retry_irq(&ma->syncp, start));
    + start = u64_stats_fetch_begin_irq(&stats->syncp);
    + counter = stats->usage_cntrs[i];
    + } while (u64_stats_fetch_retry_irq(&stats->syncp,
    + start));

    masks_and_count[i].counter += counter;
    }
    --- a/net/openvswitch/flow_table.h
    +++ b/net/openvswitch/flow_table.h
    @@ -38,12 +38,16 @@ struct mask_count {
    u64 counter;
    };

    +struct mask_array_stats {
    + struct u64_stats_sync syncp;
    + u64 usage_cntrs[];
    +};
    +
    struct mask_array {
    struct rcu_head rcu;
    int count, max;
    - u64 __percpu *masks_usage_cntr;
    + struct mask_array_stats __percpu *masks_usage_stats;
    u64 *masks_usage_zero_cntr;
    - struct u64_stats_sync syncp;
    struct sw_flow_mask __rcu *masks[];
    };


    \
     
     \ /
      Last update: 2020-10-27 16:22    [W:2.646 / U:0.100 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site