Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Gavi Teitz | 1595 | 46.35% | 4 | 9.09% |
Amir Vadai | 980 | 28.48% | 6 | 13.64% |
Vlad Buslov | 362 | 10.52% | 6 | 13.64% |
Avihai Horon | 206 | 5.99% | 3 | 6.82% |
Hadar Hen Zion | 47 | 1.37% | 1 | 2.27% |
Paul Blakey | 39 | 1.13% | 1 | 2.27% |
Oz Shlomo | 33 | 0.96% | 1 | 2.27% |
Maor Gottlieb | 23 | 0.67% | 4 | 9.09% |
Eugenia Emantayev | 20 | 0.58% | 1 | 2.27% |
Raed Salem | 17 | 0.49% | 1 | 2.27% |
Ariel Levkovich | 17 | 0.49% | 1 | 2.27% |
Mark Bloch | 16 | 0.46% | 1 | 2.27% |
Eli Cohen | 15 | 0.44% | 1 | 2.27% |
Rabie Loulou | 14 | 0.41% | 1 | 2.27% |
Américo Wang | 13 | 0.38% | 1 | 2.27% |
Daniel Jurgens | 11 | 0.32% | 2 | 4.55% |
Or Gerlitz | 10 | 0.29% | 1 | 2.27% |
Maor Dickman | 6 | 0.17% | 1 | 2.27% |
Kees Cook | 5 | 0.15% | 1 | 2.27% |
Gustavo A. R. Silva | 5 | 0.15% | 2 | 4.55% |
Bodong Wang | 3 | 0.09% | 2 | 4.55% |
Majd Dibbiny | 2 | 0.06% | 1 | 2.27% |
Aviv Heller | 2 | 0.06% | 1 | 2.27% |
Total | 3441 | 44 |
/* * Copyright (c) 2016, Mellanox Technologies. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include <linux/mlx5/driver.h> #include <linux/mlx5/fs.h> #include <linux/rbtree.h> #include "mlx5_core.h" #include "fs_core.h" #include "fs_cmd.h" #define MLX5_FC_STATS_PERIOD msecs_to_jiffies(1000) #define MLX5_FC_BULK_QUERY_ALLOC_PERIOD msecs_to_jiffies(180 * 1000) /* Max number of counters to query in bulk read is 32K */ #define MLX5_SW_MAX_COUNTERS_BULK BIT(15) #define MLX5_INIT_COUNTERS_BULK 8 #define MLX5_FC_POOL_MAX_THRESHOLD BIT(18) #define MLX5_FC_POOL_USED_BUFF_RATIO 10 struct mlx5_fc_cache { u64 packets; u64 bytes; u64 lastuse; }; struct mlx5_fc { struct list_head list; struct llist_node addlist; struct llist_node dellist; /* last{packets,bytes} members are used when calculating the delta since * last reading */ u64 lastpackets; u64 lastbytes; struct mlx5_fc_bulk *bulk; u32 id; bool aging; struct mlx5_fc_cache cache ____cacheline_aligned_in_smp; }; static void mlx5_fc_pool_init(struct mlx5_fc_pool *fc_pool, struct mlx5_core_dev *dev); static void mlx5_fc_pool_cleanup(struct mlx5_fc_pool *fc_pool); static struct mlx5_fc *mlx5_fc_pool_acquire_counter(struct mlx5_fc_pool *fc_pool); static void mlx5_fc_pool_release_counter(struct mlx5_fc_pool *fc_pool, struct mlx5_fc *fc); /* locking scheme: * * It is the responsibility of the user to prevent concurrent calls or bad * ordering to mlx5_fc_create(), mlx5_fc_destroy() and accessing a reference * to struct mlx5_fc. * e.g en_tc.c is protected by RTNL lock of its caller, and will never call a * dump (access to struct mlx5_fc) after a counter is destroyed. * * access to counter list: * - create (user context) * - mlx5_fc_create() only adds to an addlist to be used by * mlx5_fc_stats_work(). addlist is a lockless single linked list * that doesn't require any additional synchronization when adding single * node. * - spawn thread to do the actual destroy * * - destroy (user context) * - add a counter to lockless dellist * - spawn thread to do the actual del * * - dump (user context) * user should not call dump after destroy * * - query (single thread workqueue context) * destroy/dump - no conflict (see destroy) * query/dump - packets and bytes might be inconsistent (since update is not * atomic) * query/create - no conflict (see create) * since every create/destroy spawn the work, only after necessary time has * elapsed, the thread will actually query the hardware. */ static struct list_head *mlx5_fc_counters_lookup_next(struct mlx5_core_dev *dev, u32 id) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; unsigned long next_id = (unsigned long)id + 1; struct mlx5_fc *counter; unsigned long tmp; rcu_read_lock(); /* skip counters that are in idr, but not yet in counters list */ idr_for_each_entry_continue_ul(&fc_stats->counters_idr, counter, tmp, next_id) { if (!list_empty(&counter->list)) break; } rcu_read_unlock(); return counter ? &counter->list : &fc_stats->counters; } static void mlx5_fc_stats_insert(struct mlx5_core_dev *dev, struct mlx5_fc *counter) { struct list_head *next = mlx5_fc_counters_lookup_next(dev, counter->id); list_add_tail(&counter->list, next); } static void mlx5_fc_stats_remove(struct mlx5_core_dev *dev, struct mlx5_fc *counter) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; list_del(&counter->list); spin_lock(&fc_stats->counters_idr_lock); WARN_ON(!idr_remove(&fc_stats->counters_idr, counter->id)); spin_unlock(&fc_stats->counters_idr_lock); } static int get_init_bulk_query_len(struct mlx5_core_dev *dev) { return min_t(int, MLX5_INIT_COUNTERS_BULK, (1 << MLX5_CAP_GEN(dev, log_max_flow_counter_bulk))); } static int get_max_bulk_query_len(struct mlx5_core_dev *dev) { return min_t(int, MLX5_SW_MAX_COUNTERS_BULK, (1 << MLX5_CAP_GEN(dev, log_max_flow_counter_bulk))); } static void update_counter_cache(int index, u32 *bulk_raw_data, struct mlx5_fc_cache *cache) { void *stats = MLX5_ADDR_OF(query_flow_counter_out, bulk_raw_data, flow_statistics[index]); u64 packets = MLX5_GET64(traffic_counter, stats, packets); u64 bytes = MLX5_GET64(traffic_counter, stats, octets); if (cache->packets == packets) return; cache->packets = packets; cache->bytes = bytes; cache->lastuse = jiffies; } static void mlx5_fc_stats_query_counter_range(struct mlx5_core_dev *dev, struct mlx5_fc *first, u32 last_id) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; bool query_more_counters = (first->id <= last_id); int cur_bulk_len = fc_stats->bulk_query_len; u32 *data = fc_stats->bulk_query_out; struct mlx5_fc *counter = first; u32 bulk_base_id; int bulk_len; int err; while (query_more_counters) { /* first id must be aligned to 4 when using bulk query */ bulk_base_id = counter->id & ~0x3; /* number of counters to query inc. the last counter */ bulk_len = min_t(int, cur_bulk_len, ALIGN(last_id - bulk_base_id + 1, 4)); err = mlx5_cmd_fc_bulk_query(dev, bulk_base_id, bulk_len, data); if (err) { mlx5_core_err(dev, "Error doing bulk query: %d\n", err); return; } query_more_counters = false; list_for_each_entry_from(counter, &fc_stats->counters, list) { int counter_index = counter->id - bulk_base_id; struct mlx5_fc_cache *cache = &counter->cache; if (counter->id >= bulk_base_id + bulk_len) { query_more_counters = true; break; } update_counter_cache(counter_index, data, cache); } } } static void mlx5_fc_free(struct mlx5_core_dev *dev, struct mlx5_fc *counter) { mlx5_cmd_fc_free(dev, counter->id); kfree(counter); } static void mlx5_fc_release(struct mlx5_core_dev *dev, struct mlx5_fc *counter) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; if (counter->bulk) mlx5_fc_pool_release_counter(&fc_stats->fc_pool, counter); else mlx5_fc_free(dev, counter); } static void mlx5_fc_stats_bulk_query_size_increase(struct mlx5_core_dev *dev) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; int max_bulk_len = get_max_bulk_query_len(dev); unsigned long now = jiffies; u32 *bulk_query_out_tmp; int max_out_len; if (fc_stats->bulk_query_alloc_failed && time_before(now, fc_stats->next_bulk_query_alloc)) return; max_out_len = mlx5_cmd_fc_get_bulk_query_out_len(max_bulk_len); bulk_query_out_tmp = kzalloc(max_out_len, GFP_KERNEL); if (!bulk_query_out_tmp) { mlx5_core_warn_once(dev, "Can't increase flow counters bulk query buffer size, insufficient memory, bulk_size(%d)\n", max_bulk_len); fc_stats->bulk_query_alloc_failed = true; fc_stats->next_bulk_query_alloc = now + MLX5_FC_BULK_QUERY_ALLOC_PERIOD; return; } kfree(fc_stats->bulk_query_out); fc_stats->bulk_query_out = bulk_query_out_tmp; fc_stats->bulk_query_len = max_bulk_len; if (fc_stats->bulk_query_alloc_failed) { mlx5_core_info(dev, "Flow counters bulk query buffer size increased, bulk_size(%d)\n", max_bulk_len); fc_stats->bulk_query_alloc_failed = false; } } static void mlx5_fc_stats_work(struct work_struct *work) { struct mlx5_core_dev *dev = container_of(work, struct mlx5_core_dev, priv.fc_stats.work.work); struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; /* Take dellist first to ensure that counters cannot be deleted before * they are inserted. */ struct llist_node *dellist = llist_del_all(&fc_stats->dellist); struct llist_node *addlist = llist_del_all(&fc_stats->addlist); struct mlx5_fc *counter = NULL, *last = NULL, *tmp; unsigned long now = jiffies; if (addlist || !list_empty(&fc_stats->counters)) queue_delayed_work(fc_stats->wq, &fc_stats->work, fc_stats->sampling_interval); llist_for_each_entry(counter, addlist, addlist) { mlx5_fc_stats_insert(dev, counter); fc_stats->num_counters++; } llist_for_each_entry_safe(counter, tmp, dellist, dellist) { mlx5_fc_stats_remove(dev, counter); mlx5_fc_release(dev, counter); fc_stats->num_counters--; } if (fc_stats->bulk_query_len < get_max_bulk_query_len(dev) && fc_stats->num_counters > get_init_bulk_query_len(dev)) mlx5_fc_stats_bulk_query_size_increase(dev); if (time_before(now, fc_stats->next_query) || list_empty(&fc_stats->counters)) return; last = list_last_entry(&fc_stats->counters, struct mlx5_fc, list); counter = list_first_entry(&fc_stats->counters, struct mlx5_fc, list); if (counter) mlx5_fc_stats_query_counter_range(dev, counter, last->id); fc_stats->next_query = now + fc_stats->sampling_interval; } static struct mlx5_fc *mlx5_fc_single_alloc(struct mlx5_core_dev *dev) { struct mlx5_fc *counter; int err; counter = kzalloc(sizeof(*counter), GFP_KERNEL); if (!counter) return ERR_PTR(-ENOMEM); err = mlx5_cmd_fc_alloc(dev, &counter->id); if (err) { kfree(counter); return ERR_PTR(err); } return counter; } static struct mlx5_fc *mlx5_fc_acquire(struct mlx5_core_dev *dev, bool aging) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; struct mlx5_fc *counter; if (aging && MLX5_CAP_GEN(dev, flow_counter_bulk_alloc) != 0) { counter = mlx5_fc_pool_acquire_counter(&fc_stats->fc_pool); if (!IS_ERR(counter)) return counter; } return mlx5_fc_single_alloc(dev); } struct mlx5_fc *mlx5_fc_create_ex(struct mlx5_core_dev *dev, bool aging) { struct mlx5_fc *counter = mlx5_fc_acquire(dev, aging); struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; int err; if (IS_ERR(counter)) return counter; INIT_LIST_HEAD(&counter->list); counter->aging = aging; if (aging) { u32 id = counter->id; counter->cache.lastuse = jiffies; counter->lastbytes = counter->cache.bytes; counter->lastpackets = counter->cache.packets; idr_preload(GFP_KERNEL); spin_lock(&fc_stats->counters_idr_lock); err = idr_alloc_u32(&fc_stats->counters_idr, counter, &id, id, GFP_NOWAIT); spin_unlock(&fc_stats->counters_idr_lock); idr_preload_end(); if (err) goto err_out_alloc; llist_add(&counter->addlist, &fc_stats->addlist); } return counter; err_out_alloc: mlx5_fc_release(dev, counter); return ERR_PTR(err); } struct mlx5_fc *mlx5_fc_create(struct mlx5_core_dev *dev, bool aging) { struct mlx5_fc *counter = mlx5_fc_create_ex(dev, aging); struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; if (aging) mod_delayed_work(fc_stats->wq, &fc_stats->work, 0); return counter; } EXPORT_SYMBOL(mlx5_fc_create); u32 mlx5_fc_id(struct mlx5_fc *counter) { return counter->id; } EXPORT_SYMBOL(mlx5_fc_id); void mlx5_fc_destroy(struct mlx5_core_dev *dev, struct mlx5_fc *counter) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; if (!counter) return; if (counter->aging) { llist_add(&counter->dellist, &fc_stats->dellist); mod_delayed_work(fc_stats->wq, &fc_stats->work, 0); return; } mlx5_fc_release(dev, counter); } EXPORT_SYMBOL(mlx5_fc_destroy); int mlx5_init_fc_stats(struct mlx5_core_dev *dev) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; int init_bulk_len; int init_out_len; spin_lock_init(&fc_stats->counters_idr_lock); idr_init(&fc_stats->counters_idr); INIT_LIST_HEAD(&fc_stats->counters); init_llist_head(&fc_stats->addlist); init_llist_head(&fc_stats->dellist); init_bulk_len = get_init_bulk_query_len(dev); init_out_len = mlx5_cmd_fc_get_bulk_query_out_len(init_bulk_len); fc_stats->bulk_query_out = kzalloc(init_out_len, GFP_KERNEL); if (!fc_stats->bulk_query_out) return -ENOMEM; fc_stats->bulk_query_len = init_bulk_len; fc_stats->wq = create_singlethread_workqueue("mlx5_fc"); if (!fc_stats->wq) goto err_wq_create; fc_stats->sampling_interval = MLX5_FC_STATS_PERIOD; INIT_DELAYED_WORK(&fc_stats->work, mlx5_fc_stats_work); mlx5_fc_pool_init(&fc_stats->fc_pool, dev); return 0; err_wq_create: kfree(fc_stats->bulk_query_out); return -ENOMEM; } void mlx5_cleanup_fc_stats(struct mlx5_core_dev *dev) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; struct llist_node *tmplist; struct mlx5_fc *counter; struct mlx5_fc *tmp; cancel_delayed_work_sync(&dev->priv.fc_stats.work); destroy_workqueue(dev->priv.fc_stats.wq); dev->priv.fc_stats.wq = NULL; tmplist = llist_del_all(&fc_stats->addlist); llist_for_each_entry_safe(counter, tmp, tmplist, addlist) mlx5_fc_release(dev, counter); list_for_each_entry_safe(counter, tmp, &fc_stats->counters, list) mlx5_fc_release(dev, counter); mlx5_fc_pool_cleanup(&fc_stats->fc_pool); idr_destroy(&fc_stats->counters_idr); kfree(fc_stats->bulk_query_out); } int mlx5_fc_query(struct mlx5_core_dev *dev, struct mlx5_fc *counter, u64 *packets, u64 *bytes) { return mlx5_cmd_fc_query(dev, counter->id, packets, bytes); } EXPORT_SYMBOL(mlx5_fc_query); u64 mlx5_fc_query_lastuse(struct mlx5_fc *counter) { return counter->cache.lastuse; } void mlx5_fc_query_cached(struct mlx5_fc *counter, u64 *bytes, u64 *packets, u64 *lastuse) { struct mlx5_fc_cache c; c = counter->cache; *bytes = c.bytes - counter->lastbytes; *packets = c.packets - counter->lastpackets; *lastuse = c.lastuse; counter->lastbytes = c.bytes; counter->lastpackets = c.packets; } void mlx5_fc_query_cached_raw(struct mlx5_fc *counter, u64 *bytes, u64 *packets, u64 *lastuse) { struct mlx5_fc_cache c = counter->cache; *bytes = c.bytes; *packets = c.packets; *lastuse = c.lastuse; } void mlx5_fc_queue_stats_work(struct mlx5_core_dev *dev, struct delayed_work *dwork, unsigned long delay) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; queue_delayed_work(fc_stats->wq, dwork, delay); } void mlx5_fc_update_sampling_interval(struct mlx5_core_dev *dev, unsigned long interval) { struct mlx5_fc_stats *fc_stats = &dev->priv.fc_stats; fc_stats->sampling_interval = min_t(unsigned long, interval, fc_stats->sampling_interval); } /* Flow counter bluks */ struct mlx5_fc_bulk { struct list_head pool_list; u32 base_id; int bulk_len; unsigned long *bitmask; struct mlx5_fc fcs[] __counted_by(bulk_len); }; static void mlx5_fc_init(struct mlx5_fc *counter, struct mlx5_fc_bulk *bulk, u32 id) { counter->bulk = bulk; counter->id = id; } static int mlx5_fc_bulk_get_free_fcs_amount(struct mlx5_fc_bulk *bulk) { return bitmap_weight(bulk->bitmask, bulk->bulk_len); } static struct mlx5_fc_bulk *mlx5_fc_bulk_create(struct mlx5_core_dev *dev) { enum mlx5_fc_bulk_alloc_bitmask alloc_bitmask; struct mlx5_fc_bulk *bulk; int err = -ENOMEM; int bulk_len; u32 base_id; int i; alloc_bitmask = MLX5_CAP_GEN(dev, flow_counter_bulk_alloc); bulk_len = alloc_bitmask > 0 ? MLX5_FC_BULK_NUM_FCS(alloc_bitmask) : 1; bulk = kvzalloc(struct_size(bulk, fcs, bulk_len), GFP_KERNEL); if (!bulk) goto err_alloc_bulk; bulk->bitmask = kvcalloc(BITS_TO_LONGS(bulk_len), sizeof(unsigned long), GFP_KERNEL); if (!bulk->bitmask) goto err_alloc_bitmask; err = mlx5_cmd_fc_bulk_alloc(dev, alloc_bitmask, &base_id); if (err) goto err_mlx5_cmd_bulk_alloc; bulk->base_id = base_id; bulk->bulk_len = bulk_len; for (i = 0; i < bulk_len; i++) { mlx5_fc_init(&bulk->fcs[i], bulk, base_id + i); set_bit(i, bulk->bitmask); } return bulk; err_mlx5_cmd_bulk_alloc: kvfree(bulk->bitmask); err_alloc_bitmask: kvfree(bulk); err_alloc_bulk: return ERR_PTR(err); } static int mlx5_fc_bulk_destroy(struct mlx5_core_dev *dev, struct mlx5_fc_bulk *bulk) { if (mlx5_fc_bulk_get_free_fcs_amount(bulk) < bulk->bulk_len) { mlx5_core_err(dev, "Freeing bulk before all counters were released\n"); return -EBUSY; } mlx5_cmd_fc_free(dev, bulk->base_id); kvfree(bulk->bitmask); kvfree(bulk); return 0; } static struct mlx5_fc *mlx5_fc_bulk_acquire_fc(struct mlx5_fc_bulk *bulk) { int free_fc_index = find_first_bit(bulk->bitmask, bulk->bulk_len); if (free_fc_index >= bulk->bulk_len) return ERR_PTR(-ENOSPC); clear_bit(free_fc_index, bulk->bitmask); return &bulk->fcs[free_fc_index]; } static int mlx5_fc_bulk_release_fc(struct mlx5_fc_bulk *bulk, struct mlx5_fc *fc) { int fc_index = fc->id - bulk->base_id; if (test_bit(fc_index, bulk->bitmask)) return -EINVAL; set_bit(fc_index, bulk->bitmask); return 0; } /* Flow counters pool API */ static void mlx5_fc_pool_init(struct mlx5_fc_pool *fc_pool, struct mlx5_core_dev *dev) { fc_pool->dev = dev; mutex_init(&fc_pool->pool_lock); INIT_LIST_HEAD(&fc_pool->fully_used); INIT_LIST_HEAD(&fc_pool->partially_used); INIT_LIST_HEAD(&fc_pool->unused); fc_pool->available_fcs = 0; fc_pool->used_fcs = 0; fc_pool->threshold = 0; } static void mlx5_fc_pool_cleanup(struct mlx5_fc_pool *fc_pool) { struct mlx5_core_dev *dev = fc_pool->dev; struct mlx5_fc_bulk *bulk; struct mlx5_fc_bulk *tmp; list_for_each_entry_safe(bulk, tmp, &fc_pool->fully_used, pool_list) mlx5_fc_bulk_destroy(dev, bulk); list_for_each_entry_safe(bulk, tmp, &fc_pool->partially_used, pool_list) mlx5_fc_bulk_destroy(dev, bulk); list_for_each_entry_safe(bulk, tmp, &fc_pool->unused, pool_list) mlx5_fc_bulk_destroy(dev, bulk); } static void mlx5_fc_pool_update_threshold(struct mlx5_fc_pool *fc_pool) { fc_pool->threshold = min_t(int, MLX5_FC_POOL_MAX_THRESHOLD, fc_pool->used_fcs / MLX5_FC_POOL_USED_BUFF_RATIO); } static struct mlx5_fc_bulk * mlx5_fc_pool_alloc_new_bulk(struct mlx5_fc_pool *fc_pool) { struct mlx5_core_dev *dev = fc_pool->dev; struct mlx5_fc_bulk *new_bulk; new_bulk = mlx5_fc_bulk_create(dev); if (!IS_ERR(new_bulk)) fc_pool->available_fcs += new_bulk->bulk_len; mlx5_fc_pool_update_threshold(fc_pool); return new_bulk; } static void mlx5_fc_pool_free_bulk(struct mlx5_fc_pool *fc_pool, struct mlx5_fc_bulk *bulk) { struct mlx5_core_dev *dev = fc_pool->dev; fc_pool->available_fcs -= bulk->bulk_len; mlx5_fc_bulk_destroy(dev, bulk); mlx5_fc_pool_update_threshold(fc_pool); } static struct mlx5_fc * mlx5_fc_pool_acquire_from_list(struct list_head *src_list, struct list_head *next_list, bool move_non_full_bulk) { struct mlx5_fc_bulk *bulk; struct mlx5_fc *fc; if (list_empty(src_list)) return ERR_PTR(-ENODATA); bulk = list_first_entry(src_list, struct mlx5_fc_bulk, pool_list); fc = mlx5_fc_bulk_acquire_fc(bulk); if (move_non_full_bulk || mlx5_fc_bulk_get_free_fcs_amount(bulk) == 0) list_move(&bulk->pool_list, next_list); return fc; } static struct mlx5_fc * mlx5_fc_pool_acquire_counter(struct mlx5_fc_pool *fc_pool) { struct mlx5_fc_bulk *new_bulk; struct mlx5_fc *fc; mutex_lock(&fc_pool->pool_lock); fc = mlx5_fc_pool_acquire_from_list(&fc_pool->partially_used, &fc_pool->fully_used, false); if (IS_ERR(fc)) fc = mlx5_fc_pool_acquire_from_list(&fc_pool->unused, &fc_pool->partially_used, true); if (IS_ERR(fc)) { new_bulk = mlx5_fc_pool_alloc_new_bulk(fc_pool); if (IS_ERR(new_bulk)) { fc = ERR_CAST(new_bulk); goto out; } fc = mlx5_fc_bulk_acquire_fc(new_bulk); list_add(&new_bulk->pool_list, &fc_pool->partially_used); } fc_pool->available_fcs--; fc_pool->used_fcs++; out: mutex_unlock(&fc_pool->pool_lock); return fc; } static void mlx5_fc_pool_release_counter(struct mlx5_fc_pool *fc_pool, struct mlx5_fc *fc) { struct mlx5_core_dev *dev = fc_pool->dev; struct mlx5_fc_bulk *bulk = fc->bulk; int bulk_free_fcs_amount; mutex_lock(&fc_pool->pool_lock); if (mlx5_fc_bulk_release_fc(bulk, fc)) { mlx5_core_warn(dev, "Attempted to release a counter which is not acquired\n"); goto unlock; } fc_pool->available_fcs++; fc_pool->used_fcs--; bulk_free_fcs_amount = mlx5_fc_bulk_get_free_fcs_amount(bulk); if (bulk_free_fcs_amount == 1) list_move_tail(&bulk->pool_list, &fc_pool->partially_used); if (bulk_free_fcs_amount == bulk->bulk_len) { list_del(&bulk->pool_list); if (fc_pool->available_fcs > fc_pool->threshold) mlx5_fc_pool_free_bulk(fc_pool, bulk); else list_add(&bulk->pool_list, &fc_pool->unused); } unlock: mutex_unlock(&fc_pool->pool_lock); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1