mir/ovs
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 09:58:01 +00:00
Code Issues Releases Wiki Activity

list: use short version of safe loops if possible.

Browse Source 
Using the SHORT version of the *_SAFE loops makes the code cleaner
and less error-prone. So, use the SHORT version and remove the extra
variable when possible.

In order to be able to use both long and short versions without changing
the name of the macro for all the clients, overload the existing name
and select the appropriate version depending on the number of arguments.

Acked-by: Dumitru Ceara <dceara@redhat.com>
Acked-by: Eelco Chaudron <echaudro@redhat.com>
Signed-off-by: Adrian Moreno <amorenoz@redhat.com>
Signed-off-by: Ilya Maximets <i.maximets@ovn.org>
This commit is contained in:
Adrian Moreno 2022-03-23 12:56:14 +01:00 committed by Ilya Maximets
parent d4566085ed
commit e9bf5bffb0
34 changed files with 218 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
include/openvswitch/list.h
View File

@ -92,7 +92,8 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
CONDITION_MULTIVAR(VAR, MEMBER, ITER_VAR(VAR) != (LIST)); \
UPDATE_MULTIVAR(VAR, ITER_VAR(VAR)->prev))
#define LIST_FOR_EACH_REVERSE_SAFE(VAR, PREV, MEMBER, LIST) \
/* LONG version of SAFE iterators. */
#define LIST_FOR_EACH_REVERSE_SAFE_LONG(VAR, PREV, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_LONG(VAR, PREV, MEMBER, (LIST)->prev, \
struct ovs_list); \
CONDITION_MULTIVAR_SAFE_LONG(VAR, PREV, MEMBER, \
@ -101,7 +102,7 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
ITER_VAR(PREV) != (LIST)); \
UPDATE_MULTIVAR_SAFE_LONG(VAR, PREV))
#define LIST_FOR_EACH_SAFE(VAR, NEXT, MEMBER, LIST) \
#define LIST_FOR_EACH_SAFE_LONG(VAR, NEXT, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_LONG(VAR, NEXT, MEMBER, (LIST)->next, \
struct ovs_list); \
CONDITION_MULTIVAR_SAFE_LONG(VAR, NEXT, MEMBER, \
@ -110,6 +111,31 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
ITER_VAR(NEXT) != (LIST)); \
UPDATE_MULTIVAR_SAFE_LONG(VAR, NEXT))
/* SHORT version of SAFE iterators. */
#define LIST_FOR_EACH_REVERSE_SAFE_SHORT(VAR, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_SHORT(VAR, MEMBER, (LIST)->prev, struct ovs_list);\
CONDITION_MULTIVAR_SAFE_SHORT(VAR, MEMBER, \
ITER_VAR(VAR) != (LIST), \
ITER_NEXT_VAR(VAR) = ITER_VAR(VAR)->prev); \
UPDATE_MULTIVAR_SAFE_SHORT(VAR))
#define LIST_FOR_EACH_SAFE_SHORT(VAR, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_SHORT(VAR, MEMBER, (LIST)->next, struct ovs_list);\
CONDITION_MULTIVAR_SAFE_SHORT(VAR, MEMBER, \
ITER_VAR(VAR) != (LIST), \
ITER_NEXT_VAR(VAR) = ITER_VAR(VAR)->next); \
UPDATE_MULTIVAR_SAFE_SHORT(VAR))
#define LIST_FOR_EACH_SAFE(...) \
OVERLOAD_SAFE_MACRO(LIST_FOR_EACH_SAFE_LONG, \
LIST_FOR_EACH_SAFE_SHORT, \
4, __VA_ARGS__)
#define LIST_FOR_EACH_REVERSE_SAFE(...) \
OVERLOAD_SAFE_MACRO(LIST_FOR_EACH_REVERSE_SAFE_LONG, \
LIST_FOR_EACH_REVERSE_SAFE_SHORT, \
4, __VA_ARGS__)
#define LIST_FOR_EACH_POP(ITER, MEMBER, LIST) \
while (!ovs_list_is_empty(LIST) ? \
(INIT_CONTAINER(ITER, ovs_list_pop_front(LIST), MEMBER), 1) : \

4
lib/conntrack.c
View File

@ -1526,14 +1526,14 @@ set_label(struct dp_packet *pkt, struct conn *conn,
static long long
ct_sweep(struct conntrack *ct, long long now, size_t limit)
{
struct conn *conn, *next;
struct conn *conn;
long long min_expiration = LLONG_MAX;
size_t count = 0;
ovs_mutex_lock(&ct->ct_lock);
for (unsigned i = 0; i < N_CT_TM; i++) {
LIST_FOR_EACH_SAFE (conn, next, exp_node, &ct->exp_lists[i]) {
LIST_FOR_EACH_SAFE (conn, exp_node, &ct->exp_lists[i]) {
ovs_mutex_lock(&conn->lock);
if (now < conn->expiration || count >= limit) {
min_expiration = MIN(min_expiration, conn->expiration);

4
lib/fat-rwlock.c
View File

@ -97,14 +97,14 @@ fat_rwlock_init(struct fat_rwlock *rwlock)
void
fat_rwlock_destroy(struct fat_rwlock *rwlock)
{
struct fat_rwlock_slot *slot, *next;
struct fat_rwlock_slot *slot;
/* Order is important here. By destroying the thread-specific data first,
* before we destroy the slots, we ensure that the thread-specific
* data destructor can't race with our loop below. */
ovsthread_key_delete(rwlock->key);
LIST_FOR_EACH_SAFE (slot, next, list_node, &rwlock->threads) {
LIST_FOR_EACH_SAFE (slot, list_node, &rwlock->threads) {
free_slot(slot);
}
ovs_mutex_destroy(&rwlock->mutex);

3
lib/id-fpool.c
View File

@ -166,11 +166,10 @@ void
id_fpool_destroy(struct id_fpool *pool)
{
struct id_slab *slab;
struct id_slab *next;
size_t i;
id_fpool_lock(&pool->pool_lock);
LIST_FOR_EACH_SAFE (slab, next, node, &pool->free_slabs) {
LIST_FOR_EACH_SAFE (slab, node, &pool->free_slabs) {
free(slab);
}
ovs_list_poison(&pool->free_slabs);

22
lib/ipf.c
View File

@ -1058,9 +1058,9 @@ ipf_send_completed_frags(struct ipf *ipf, struct dp_packet_batch *pb,
}
ovs_mutex_lock(&ipf->ipf_lock);
struct ipf_list *ipf_list, *next;
struct ipf_list *ipf_list;
LIST_FOR_EACH_SAFE (ipf_list, next, list_node, &ipf->frag_complete_list) {
LIST_FOR_EACH_SAFE (ipf_list, list_node, &ipf->frag_complete_list) {
if (ipf_send_frags_in_list(ipf, ipf_list, pb, IPF_FRAG_COMPLETED_LIST,
v6, now)) {
ipf_completed_list_clean(&ipf->frag_lists, ipf_list);
@ -1090,10 +1090,10 @@ ipf_send_expired_frags(struct ipf *ipf, struct dp_packet_batch *pb,
}
ovs_mutex_lock(&ipf->ipf_lock);
struct ipf_list *ipf_list, *next;
struct ipf_list *ipf_list;
size_t lists_removed = 0;
LIST_FOR_EACH_SAFE (ipf_list, next, list_node, &ipf->frag_exp_list) {
LIST_FOR_EACH_SAFE (ipf_list, list_node, &ipf->frag_exp_list) {
if (now <= ipf_list->expiration ||
lists_removed >= IPF_FRAG_LIST_MAX_EXPIRED) {
break;
@ -1121,9 +1121,9 @@ ipf_execute_reass_pkts(struct ipf *ipf, struct dp_packet_batch *pb)
}
ovs_mutex_lock(&ipf->ipf_lock);
struct reassembled_pkt *rp, *next;
struct reassembled_pkt *rp;
LIST_FOR_EACH_SAFE (rp, next, rp_list_node, &ipf->reassembled_pkt_list) {
LIST_FOR_EACH_SAFE (rp, rp_list_node, &ipf->reassembled_pkt_list) {
if (!rp->list->reass_execute_ctx &&
ipf_dp_packet_batch_add(pb, rp->pkt, false)) {
rp->list->reass_execute_ctx = rp->pkt;
@ -1144,9 +1144,9 @@ ipf_post_execute_reass_pkts(struct ipf *ipf,
}
ovs_mutex_lock(&ipf->ipf_lock);
struct reassembled_pkt *rp, *next;
struct reassembled_pkt *rp;
LIST_FOR_EACH_SAFE (rp, next, rp_list_node, &ipf->reassembled_pkt_list) {
LIST_FOR_EACH_SAFE (rp, rp_list_node, &ipf->reassembled_pkt_list) {
const size_t pb_cnt = dp_packet_batch_size(pb);
int pb_idx;
struct dp_packet *pkt;
@ -1271,15 +1271,15 @@ ipf_clean_thread_main(void *f)
ovs_mutex_lock(&ipf->ipf_lock);
struct ipf_list *ipf_list, *next;
LIST_FOR_EACH_SAFE (ipf_list, next, list_node,
struct ipf_list *ipf_list;
LIST_FOR_EACH_SAFE (ipf_list, list_node,
&ipf->frag_exp_list) {
if (ipf_purge_list_check(ipf, ipf_list, now)) {
ipf_expiry_list_clean(&ipf->frag_lists, ipf_list);
}
}
LIST_FOR_EACH_SAFE (ipf_list, next, list_node,
LIST_FOR_EACH_SAFE (ipf_list, list_node,
&ipf->frag_complete_list) {
if (ipf_purge_list_check(ipf, ipf_list, now)) {
ipf_completed_list_clean(&ipf->frag_lists, ipf_list);

7
lib/lldp/lldpd-structs.c
View File

@ -64,11 +64,11 @@ lldpd_remote_cleanup(struct lldpd_hardware *hw,
struct lldpd_port *),
bool all)
{
struct lldpd_port *port, *port_next;
struct lldpd_port *port;
time_t now = time_now();
VLOG_DBG("cleanup remote port on %s", hw->h_ifname);
LIST_FOR_EACH_SAFE (port, port_next, p_entries, &hw->h_rports) {
LIST_FOR_EACH_SAFE (port, p_entries, &hw->h_rports) {
bool del = all;
if (!all && expire &&
(now >= port->p_lastupdate + port->p_chassis->c_ttl)) {
@ -99,11 +99,10 @@ static void
lldpd_aa_maps_cleanup(struct lldpd_port *port)
{
struct lldpd_aa_isid_vlan_maps_tlv *isid_vlan_map = NULL;
struct lldpd_aa_isid_vlan_maps_tlv *isid_vlan_map_next = NULL;
if (!ovs_list_is_empty(&port->p_isid_vlan_maps)) {
LIST_FOR_EACH_SAFE (isid_vlan_map, isid_vlan_map_next, m_entries,
LIST_FOR_EACH_SAFE (isid_vlan_map, m_entries,
&port->p_isid_vlan_maps) {
ovs_list_remove(&isid_vlan_map->m_entries);

8
lib/lldp/lldpd.c
View File

@ -134,12 +134,12 @@ lldpd_hardware_cleanup(struct lldpd *cfg, struct lldpd_hardware *hardware)
void
lldpd_cleanup(struct lldpd *cfg)
{
struct lldpd_hardware *hw, *hw_next;
struct lldpd_chassis *chassis, *chassis_next;
struct lldpd_hardware *hw;
struct lldpd_chassis *chassis;
VLOG_DBG("cleanup all ports");
LIST_FOR_EACH_SAFE (hw, hw_next, h_entries, &cfg->g_hardware) {
LIST_FOR_EACH_SAFE (hw, h_entries, &cfg->g_hardware) {
if (!hw->h_flags) {
ovs_list_remove(&hw->h_entries);
lldpd_remote_cleanup(hw, NULL, true);
@ -151,7 +151,7 @@ lldpd_cleanup(struct lldpd *cfg)
VLOG_DBG("cleanup all chassis");
LIST_FOR_EACH_SAFE (chassis, chassis_next, list, &cfg->g_chassis) {
LIST_FOR_EACH_SAFE (chassis, list, &cfg->g_chassis) {
if (chassis->c_refcount == 0) {
ovs_list_remove(&chassis->list);
lldpd_chassis_cleanup(chassis, 1);

12
lib/mcast-snooping.c
View File

@ -356,11 +356,11 @@ mcast_snooping_prune_expired(struct mcast_snooping *ms,
OVS_REQ_WRLOCK(ms->rwlock)
{
int expired;
struct mcast_group_bundle *b, *next_b;
struct mcast_group_bundle *b;
time_t timenow = time_now();
expired = 0;
LIST_FOR_EACH_SAFE (b, next_b, bundle_node, &grp->bundle_lru) {
LIST_FOR_EACH_SAFE (b, bundle_node, &grp->bundle_lru) {
/* This list is sorted on expiration time. */
if (b->expires > timenow) {
break;
@ -946,15 +946,15 @@ mcast_snooping_wait(struct mcast_snooping *ms)
void
mcast_snooping_flush_bundle(struct mcast_snooping *ms, void *port)
{
struct mcast_group *g, *next_g;
struct mcast_mrouter_bundle *m, *next_m;
struct mcast_group *g;
struct mcast_mrouter_bundle *m;
if (!mcast_snooping_enabled(ms)) {
return;
}
ovs_rwlock_wrlock(&ms->rwlock);
LIST_FOR_EACH_SAFE (g, next_g, group_node, &ms->group_lru) {
LIST_FOR_EACH_SAFE (g, group_node, &ms->group_lru) {
if (mcast_group_delete_bundle(ms, g, port)) {
ms->need_revalidate = true;
@ -964,7 +964,7 @@ mcast_snooping_flush_bundle(struct mcast_snooping *ms, void *port)
}
}
LIST_FOR_EACH_SAFE (m, next_m, mrouter_node, &ms->mrouter_lru) {
LIST_FOR_EACH_SAFE (m, mrouter_node, &ms->mrouter_lru) {
if (m->port == port) {
mcast_snooping_flush_mrouter(m);
ms->need_revalidate = true;

4
lib/netdev-afxdp.c
View File

@ -235,11 +235,11 @@ netdev_afxdp_cleanup_unused_pool(struct unused_pool *pool)
static void
netdev_afxdp_sweep_unused_pools(void *aux OVS_UNUSED)
{
struct unused_pool *pool, *next;
struct unused_pool *pool;
unsigned int count;
ovs_mutex_lock(&unused_pools_mutex);
LIST_FOR_EACH_SAFE (pool, next, list_node, &unused_pools) {
LIST_FOR_EACH_SAFE (pool, list_node, &unused_pools) {
count = umem_pool_count(&pool->umem_info->mpool);
ovs_assert(count + pool->lost_in_rings <= NUM_FRAMES);

4
lib/netdev-dpdk.c
View File

@ -623,9 +623,9 @@ dpdk_mp_full(const struct rte_mempool *mp) OVS_REQUIRES(dpdk_mp_mutex)
static void
dpdk_mp_sweep(void) OVS_REQUIRES(dpdk_mp_mutex)
{
struct dpdk_mp *dmp, *next;
struct dpdk_mp *dmp;
LIST_FOR_EACH_SAFE (dmp, next, list_node, &dpdk_mp_list) {
LIST_FOR_EACH_SAFE (dmp, list_node, &dpdk_mp_list) {
if (!dmp->refcount && dpdk_mp_full(dmp->mp)) {
VLOG_DBG("Freeing mempool \"%s\"", dmp->mp->name);
ovs_list_remove(&dmp->list_node);

4
lib/ofp-msgs.c
View File

@ -1290,8 +1290,8 @@ ofpmp_assembler_execute(struct hmap *assembler, struct ofpbuf *msg,
* on either side by parts with 0-byte bodies. We remove the 0-byte
* ones here to simplify processing later.
*/
struct ofpbuf *b, *next;
LIST_FOR_EACH_SAFE (b, next, list_node, out) {
struct ofpbuf *b;
LIST_FOR_EACH_SAFE (b, list_node, out) {
if (b->size <= min_len && !ovs_list_is_short(out)) {
ovs_list_remove(&b->list_node);
ofpbuf_delete(b);

12
lib/ovs-lldp.c
View File

@ -559,9 +559,9 @@ aa_mapping_unregister_mapping(struct lldp *lldp,
struct lldpd_hardware *hw,
struct aa_mapping_internal *m)
{
struct lldpd_aa_isid_vlan_maps_tlv *lm, *lm_next;
struct lldpd_aa_isid_vlan_maps_tlv *lm;
LIST_FOR_EACH_SAFE (lm, lm_next, m_entries,
LIST_FOR_EACH_SAFE (lm, m_entries,
&hw->h_lport.p_isid_vlan_maps) {
uint32_t isid = lm->isid_vlan_data.isid;
@ -953,8 +953,8 @@ lldp_ref(const struct lldp *lldp_)
void
lldp_destroy_dummy(struct lldp *lldp)
{
struct lldpd_hardware *hw, *hw_next;
struct lldpd_chassis *chassis, *chassis_next;
struct lldpd_hardware *hw;
struct lldpd_chassis *chassis;
struct lldpd *cfg;
if (!lldp) {
@ -963,13 +963,13 @@ lldp_destroy_dummy(struct lldp *lldp)
cfg = lldp->lldpd;
LIST_FOR_EACH_SAFE (hw, hw_next, h_entries, &cfg->g_hardware) {
LIST_FOR_EACH_SAFE (hw, h_entries, &cfg->g_hardware) {
ovs_list_remove(&hw->h_entries);
free(hw->h_lport.p_lastframe);
free(hw);
}
LIST_FOR_EACH_SAFE (chassis, chassis_next, list, &cfg->g_chassis) {
LIST_FOR_EACH_SAFE (chassis, list, &cfg->g_chassis) {
ovs_list_remove(&chassis->list);
free(chassis);
}

30
lib/ovsdb-idl.c
View File

@ -396,18 +396,18 @@ ovsdb_idl_clear(struct ovsdb_idl *db)
}
HMAP_FOR_EACH_SAFE (row, next_row, hmap_node, &table->rows) {
struct ovsdb_idl_arc *arc, *next_arc;
struct ovsdb_idl_arc *arc;
if (!ovsdb_idl_row_is_orphan(row)) {
ovsdb_idl_remove_from_indexes(row);
ovsdb_idl_row_unparse(row);
}
LIST_FOR_EACH_SAFE (arc, next_arc, src_node, &row->src_arcs) {
LIST_FOR_EACH_SAFE (arc, src_node, &row->src_arcs) {
ovs_list_remove(&arc->src_node);
ovs_list_remove(&arc->dst_node);
free(arc);
}
LIST_FOR_EACH_SAFE (arc, next_arc, dst_node, &row->dst_arcs) {
LIST_FOR_EACH_SAFE (arc, dst_node, &row->dst_arcs) {
ovs_list_remove(&arc->src_node);
ovs_list_remove(&arc->dst_node);
free(arc);
@ -1345,9 +1345,9 @@ ovsdb_idl_track_clear__(struct ovsdb_idl *idl, bool flush_all)
struct ovsdb_idl_table *table = &idl->tables[i];
if (!ovs_list_is_empty(&table->track_list)) {
struct ovsdb_idl_row *row, *next;
struct ovsdb_idl_row *row;
LIST_FOR_EACH_SAFE(row, next, track_node, &table->track_list) {
LIST_FOR_EACH_SAFE (row, track_node, &table->track_list) {
if (row->updated) {
free(row->updated);
row->updated = NULL;
@ -1480,9 +1480,9 @@ ovsdb_idl_parse_update(struct ovsdb_idl *idl,
static void
ovsdb_idl_reparse_deleted(struct ovsdb_idl *db)
{
struct ovsdb_idl_row *row, *next;
struct ovsdb_idl_row *row;
LIST_FOR_EACH_SAFE (row, next, track_node, &db->deleted_untracked_rows) {
LIST_FOR_EACH_SAFE (row, track_node, &db->deleted_untracked_rows) {
ovsdb_idl_row_untrack_change(row);
add_tracked_change_for_references(row);
ovsdb_idl_row_reparse_backrefs(row);
@ -1906,8 +1906,8 @@ ovsdb_idl_index_create2(struct ovsdb_idl *idl,
static void
ovsdb_idl_destroy_indexes(struct ovsdb_idl_table *table)
{
struct ovsdb_idl_index *index, *next;
LIST_FOR_EACH_SAFE (index, next, node, &table->indexes) {
struct ovsdb_idl_index *index;
LIST_FOR_EACH_SAFE (index, node, &table->indexes) {
skiplist_destroy(index->skiplist, NULL);
free(index->columns);
free(index);
@ -2145,12 +2145,12 @@ ovsdb_idl_row_clear_new(struct ovsdb_idl_row *row)
static void
ovsdb_idl_row_clear_arcs(struct ovsdb_idl_row *row, bool destroy_dsts)
{
struct ovsdb_idl_arc *arc, *next;
struct ovsdb_idl_arc *arc;
/* Delete all forward arcs. If 'destroy_dsts', destroy any orphaned rows
* that this causes to be unreferenced.
*/
LIST_FOR_EACH_SAFE (arc, next, src_node, &row->src_arcs) {
LIST_FOR_EACH_SAFE (arc, src_node, &row->src_arcs) {
ovs_list_remove(&arc->dst_node);
if (destroy_dsts
&& ovsdb_idl_row_is_orphan(arc->dst)
@ -2166,7 +2166,7 @@ ovsdb_idl_row_clear_arcs(struct ovsdb_idl_row *row, bool destroy_dsts)
static void
ovsdb_idl_row_reparse_backrefs(struct ovsdb_idl_row *row)
{
struct ovsdb_idl_arc *arc, *next;
struct ovsdb_idl_arc *arc;
/* This is trickier than it looks. ovsdb_idl_row_clear_arcs() will destroy
* 'arc', so we need to use the "safe" variant of list traversal. However,
@ -2178,7 +2178,7 @@ ovsdb_idl_row_reparse_backrefs(struct ovsdb_idl_row *row)
* (If duplicate arcs were possible then we would need to make sure that
* 'next' didn't also point into 'arc''s destination, but we forbid
* duplicate arcs.) */
LIST_FOR_EACH_SAFE (arc, next, dst_node, &row->dst_arcs) {
LIST_FOR_EACH_SAFE (arc, dst_node, &row->dst_arcs) {
struct ovsdb_idl_row *ref = arc->src;
ovsdb_idl_row_unparse(ref);
@ -2329,9 +2329,9 @@ ovsdb_idl_row_destroy_postprocess(struct ovsdb_idl *idl)
struct ovsdb_idl_table *table = &idl->tables[i];
if (!ovs_list_is_empty(&table->track_list)) {
struct ovsdb_idl_row *row, *next;
struct ovsdb_idl_row *row;
LIST_FOR_EACH_SAFE(row, next, track_node, &table->track_list) {
LIST_FOR_EACH_SAFE (row, track_node, &table->track_list) {
if (!ovsdb_idl_track_is_set(row->table)) {
ovs_list_remove(&row->track_node);
ovsdb_idl_row_unparse(row);

4
lib/seq.c
View File

@ -297,9 +297,9 @@ static void
seq_thread_woke(struct seq_thread *thread)
OVS_REQUIRES(seq_mutex)
{
struct seq_waiter *waiter, *next_waiter;
struct seq_waiter *waiter;
LIST_FOR_EACH_SAFE (waiter, next_waiter, list_node, &thread->waiters) {
LIST_FOR_EACH_SAFE (waiter, list_node, &thread->waiters) {
ovs_assert(waiter->thread == thread);
seq_waiter_destroy(waiter);
}

16
lib/tnl-ports.c
View File

@ -259,14 +259,14 @@ ipdev_map_delete(struct ip_device *ip_dev, ovs_be16 tp_port, uint8_t nw_proto)
void
tnl_port_map_delete(odp_port_t port, const char type[])
{
struct tnl_port *p, *next;
struct tnl_port *p;
struct ip_device *ip_dev;
uint8_t nw_proto;
nw_proto = tnl_type_to_nw_proto(type);
ovs_mutex_lock(&mutex);
LIST_FOR_EACH_SAFE(p, next, node, &port_list) {
LIST_FOR_EACH_SAFE (p, node, &port_list) {
if (p->port == port && p->nw_proto == nw_proto &&
ovs_refcount_unref_relaxed(&p->ref_cnt) == 1) {
ovs_list_remove(&p->node);
@ -444,11 +444,11 @@ delete_ipdev(struct ip_device *ip_dev)
void
tnl_port_map_insert_ipdev(const char dev_name[])
{
struct ip_device *ip_dev, *next;
struct ip_device *ip_dev;
ovs_mutex_lock(&mutex);
LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
LIST_FOR_EACH_SAFE (ip_dev, node, &addr_list) {
if (!strcmp(netdev_get_name(ip_dev->dev), dev_name)) {
if (ip_dev->change_seq == netdev_get_change_seq(ip_dev->dev)) {
goto out;
@ -466,10 +466,10 @@ out:
void
tnl_port_map_delete_ipdev(const char dev_name[])
{
struct ip_device *ip_dev, *next;
struct ip_device *ip_dev;
ovs_mutex_lock(&mutex);
LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
LIST_FOR_EACH_SAFE (ip_dev, node, &addr_list) {
if (!strcmp(netdev_get_name(ip_dev->dev), dev_name)) {
delete_ipdev(ip_dev);
}
@ -480,10 +480,10 @@ tnl_port_map_delete_ipdev(const char dev_name[])
void
tnl_port_map_run(void)
{
struct ip_device *ip_dev, *next;
struct ip_device *ip_dev;
ovs_mutex_lock(&mutex);
LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
LIST_FOR_EACH_SAFE (ip_dev, node, &addr_list) {
char dev_name[IFNAMSIZ];
if (ip_dev->change_seq == netdev_get_change_seq(ip_dev->dev)) {

8
lib/unixctl.c
View File

@ -390,8 +390,8 @@ unixctl_server_run(struct unixctl_server *server)
}
}
struct unixctl_conn *conn, *next;
LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
struct unixctl_conn *conn;
LIST_FOR_EACH_SAFE (conn, node, &server->conns) {
int error = run_connection(conn);
if (error && error != EAGAIN) {
kill_connection(conn);
@ -422,9 +422,9 @@ void
unixctl_server_destroy(struct unixctl_server *server)
{
if (server) {
struct unixctl_conn *conn, *next;
struct unixctl_conn *conn;
LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
LIST_FOR_EACH_SAFE (conn, node, &server->conns) {
kill_connection(conn);
}

4
lib/vconn.c
View File

@ -960,8 +960,8 @@ vconn_transact_multipart(struct vconn *vconn,
ovs_list_init(replies);
/* Send all the requests. */
struct ofpbuf *b, *next;
LIST_FOR_EACH_SAFE (b, next, list_node, requests) {
struct ofpbuf *b;
LIST_FOR_EACH_SAFE (b, list_node, requests) {
ovs_list_remove(&b->list_node);
int error = vconn_send_block(vconn, b);
if (error) {

8
ofproto/connmgr.c
View File

@ -351,8 +351,8 @@ connmgr_run(struct connmgr *mgr,
}
}
struct ofconn *ofconn, *next_ofconn;
LIST_FOR_EACH_SAFE (ofconn, next_ofconn, connmgr_node, &mgr->conns) {
struct ofconn *ofconn;
LIST_FOR_EACH_SAFE (ofconn, connmgr_node, &mgr->conns) {
ofconn_run(ofconn, handle_openflow);
}
ofmonitor_run(mgr);
@ -1953,8 +1953,8 @@ static void
ofservice_close_all(struct ofservice *ofservice)
OVS_REQUIRES(ofproto_mutex)
{
struct ofconn *ofconn, *next;
LIST_FOR_EACH_SAFE (ofconn, next, ofservice_node, &ofservice->conns) {
struct ofconn *ofconn;
LIST_FOR_EACH_SAFE (ofconn, ofservice_node, &ofservice->conns) {
ofconn_destroy(ofconn);
}
}

4
ofproto/ofproto-dpif-ipfix.c
View File

@ -2799,7 +2799,7 @@ dpif_ipfix_cache_expire(struct dpif_ipfix_exporter *exporter,
bool forced_end, const uint64_t export_time_usec,
const uint32_t export_time_sec)
{
struct ipfix_flow_cache_entry *entry, *next_entry;
struct ipfix_flow_cache_entry *entry;
uint64_t max_flow_start_timestamp_usec;
bool template_msg_sent = false;
enum ipfix_flow_end_reason flow_end_reason;
@ -2811,7 +2811,7 @@ dpif_ipfix_cache_expire(struct dpif_ipfix_exporter *exporter,
max_flow_start_timestamp_usec = export_time_usec -
1000000LL * exporter->cache_active_timeout;
LIST_FOR_EACH_SAFE (entry, next_entry, cache_flow_start_timestamp_list_node,
LIST_FOR_EACH_SAFE (entry, cache_flow_start_timestamp_list_node,
&exporter->cache_flow_start_timestamp_list) {
if (forced_end) {
flow_end_reason = FORCED_END;

4
ofproto/ofproto-dpif-trace.c
View File

@ -65,8 +65,8 @@ static void
oftrace_node_list_destroy(struct ovs_list *nodes)
{
if (nodes) {
struct oftrace_node *node, *next;
LIST_FOR_EACH_SAFE (node, next, node, nodes) {
struct oftrace_node *node;
LIST_FOR_EACH_SAFE (node, node, nodes) {
ovs_list_remove(&node->node);
oftrace_node_destroy(node);
}

4
ofproto/ofproto-dpif-xlate.c
View File

@ -1282,7 +1282,7 @@ xlate_ofproto_set(struct ofproto_dpif *ofproto, const char *name,
static void
xlate_xbridge_remove(struct xlate_cfg *xcfg, struct xbridge *xbridge)
{
struct xbundle *xbundle, *next_xbundle;
struct xbundle *xbundle;
struct xport *xport, *next_xport;
if (!xbridge) {
@ -1293,7 +1293,7 @@ xlate_xbridge_remove(struct xlate_cfg *xcfg, struct xbridge *xbridge)
xlate_xport_remove(xcfg, xport);
}
LIST_FOR_EACH_SAFE (xbundle, next_xbundle, list_node, &xbridge->xbundles) {
LIST_FOR_EACH_SAFE (xbundle, list_node, &xbridge->xbundles) {
xlate_xbundle_remove(xcfg, xbundle);
}

24
ofproto/ofproto-dpif.c
View File

@ -1936,7 +1936,7 @@ run(struct ofproto *ofproto_)
new_dump_seq = seq_read(udpif_dump_seq(ofproto->backer->udpif));
if (ofproto->dump_seq != new_dump_seq) {
struct rule *rule, *next_rule;
struct rule *rule;
long long now = time_msec();
/* We know stats are relatively fresh, so now is a good time to do some
@ -1946,7 +1946,7 @@ run(struct ofproto *ofproto_)
/* Expire OpenFlow flows whose idle_timeout or hard_timeout
* has passed. */
ovs_mutex_lock(&ofproto_mutex);
LIST_FOR_EACH_SAFE (rule, next_rule, expirable,
LIST_FOR_EACH_SAFE (rule, expirable,
&ofproto->up.expirable) {
rule_expire(rule_dpif_cast(rule), now);
}
@ -3103,11 +3103,11 @@ bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos)
{
struct ofproto_dpif *ofproto = bundle->ofproto;
struct mac_learning *ml = ofproto->ml;
struct mac_entry *mac, *next_mac;
struct mac_entry *mac;
ofproto->backer->need_revalidate = REV_RECONFIGURE;
ovs_rwlock_wrlock(&ml->rwlock);
LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
LIST_FOR_EACH_SAFE (mac, lru_node, &ml->lrus) {
if (mac_entry_get_port(ml, mac) == bundle) {
if (all_ofprotos) {
struct ofproto_dpif *o;
@ -3138,13 +3138,13 @@ bundle_move(struct ofbundle *old, struct ofbundle *new)
{
struct ofproto_dpif *ofproto = old->ofproto;
struct mac_learning *ml = ofproto->ml;
struct mac_entry *mac, *next_mac;
struct mac_entry *mac;
ovs_assert(new->ofproto == old->ofproto);
ofproto->backer->need_revalidate = REV_RECONFIGURE;
ovs_rwlock_wrlock(&ml->rwlock);
LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
LIST_FOR_EACH_SAFE (mac, lru_node, &ml->lrus) {
if (mac_entry_get_port(ml, mac) == old) {
mac_entry_set_port(ml, mac, new);
}
@ -3241,7 +3241,7 @@ static void
bundle_destroy(struct ofbundle *bundle)
{
struct ofproto_dpif *ofproto;
struct ofport_dpif *port, *next_port;
struct ofport_dpif *port;
if (!bundle) {
return;
@ -3254,7 +3254,7 @@ bundle_destroy(struct ofbundle *bundle)
xlate_bundle_remove(bundle);
xlate_txn_commit();
LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
LIST_FOR_EACH_SAFE (port, bundle_node, &bundle->ports) {
bundle_del_port(port);
}
@ -3344,9 +3344,7 @@ bundle_set(struct ofproto *ofproto_, void *aux,
}
}
if (!ok || ovs_list_size(&bundle->ports) != s->n_members) {
struct ofport_dpif *next_port;
LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
LIST_FOR_EACH_SAFE (port, bundle_node, &bundle->ports) {
for (i = 0; i < s->n_members; i++) {
if (s->members[i] == port->up.ofp_port) {
goto found;
@ -5551,9 +5549,9 @@ ct_zone_timeout_policy_sweep(struct dpif_backer *backer)
{
if (!ovs_list_is_empty(&backer->ct_tp_kill_list)
&& time_msec() >= timeout_policy_cleanup_timer) {
struct ct_timeout_policy *ct_tp, *next;
struct ct_timeout_policy *ct_tp;
LIST_FOR_EACH_SAFE (ct_tp, next, list_node, &backer->ct_tp_kill_list) {
LIST_FOR_EACH_SAFE (ct_tp, list_node, &backer->ct_tp_kill_list) {
if (!ct_dpif_del_timeout_policy(backer->dpif, ct_tp->tp_id)) {
ovs_list_remove(&ct_tp->list_node);
ct_timeout_policy_destroy(ct_tp, backer->tp_ids);

16
ovsdb/jsonrpc-server.c
View File

@ -585,9 +585,9 @@ ovsdb_jsonrpc_session_set_options(struct ovsdb_jsonrpc_session *session,
static void
ovsdb_jsonrpc_session_run_all(struct ovsdb_jsonrpc_remote *remote)
{
struct ovsdb_jsonrpc_session *s, *next;
struct ovsdb_jsonrpc_session *s;
LIST_FOR_EACH_SAFE (s, next, node, &remote->sessions) {
LIST_FOR_EACH_SAFE (s, node, &remote->sessions) {
int error = ovsdb_jsonrpc_session_run(s);
if (error) {
ovsdb_jsonrpc_session_close(s);
@ -642,9 +642,9 @@ ovsdb_jsonrpc_session_get_memory_usage_all(
static void
ovsdb_jsonrpc_session_close_all(struct ovsdb_jsonrpc_remote *remote)
{
struct ovsdb_jsonrpc_session *s, *next;
struct ovsdb_jsonrpc_session *s;
LIST_FOR_EACH_SAFE (s, next, node, &remote->sessions) {
LIST_FOR_EACH_SAFE (s, node, &remote->sessions) {
ovsdb_jsonrpc_session_close(s);
}
}
@ -660,9 +660,9 @@ static void
ovsdb_jsonrpc_session_reconnect_all(struct ovsdb_jsonrpc_remote *remote,
bool force, const char *comment)
{
struct ovsdb_jsonrpc_session *s, *next;
struct ovsdb_jsonrpc_session *s;
LIST_FOR_EACH_SAFE (s, next, node, &remote->sessions) {
LIST_FOR_EACH_SAFE (s, node, &remote->sessions) {
if (force || !s->db_change_aware) {
jsonrpc_session_force_reconnect(s->js);
if (comment && jsonrpc_session_is_connected(s->js)) {
@ -1226,8 +1226,8 @@ ovsdb_jsonrpc_trigger_complete_all(struct ovsdb_jsonrpc_session *s)
static void
ovsdb_jsonrpc_trigger_complete_done(struct ovsdb_jsonrpc_session *s)
{
struct ovsdb_jsonrpc_trigger *trigger, *next;
LIST_FOR_EACH_SAFE (trigger, next, trigger.node, &s->up.completions) {
struct ovsdb_jsonrpc_trigger *trigger;
LIST_FOR_EACH_SAFE (trigger, trigger.node, &s->up.completions) {
ovsdb_jsonrpc_trigger_complete(trigger);
}
}

24
ovsdb/monitor.c
View File

@ -638,8 +638,8 @@ ovsdb_monitor_change_set_destroy(struct ovsdb_monitor_change_set *mcs)
{
ovs_list_remove(&mcs->list_node);
struct ovsdb_monitor_change_set_for_table *mcst, *next_mcst;
LIST_FOR_EACH_SAFE (mcst, next_mcst, list_in_change_set,
struct ovsdb_monitor_change_set_for_table *mcst;
LIST_FOR_EACH_SAFE (mcst, list_in_change_set,
&mcs->change_set_for_tables) {
ovs_list_remove(&mcst->list_in_change_set);
ovs_list_remove(&mcst->list_in_mt);
@ -1711,8 +1711,8 @@ ovsdb_monitor_destroy(struct ovsdb_monitor *dbmon)
ovsdb_monitor_json_cache_flush(dbmon);
hmap_destroy(&dbmon->json_cache);
struct ovsdb_monitor_change_set *cs, *cs_next;
LIST_FOR_EACH_SAFE (cs, cs_next, list_node, &dbmon->change_sets) {
struct ovsdb_monitor_change_set *cs;
LIST_FOR_EACH_SAFE (cs, list_node, &dbmon->change_sets) {
ovsdb_monitor_change_set_destroy(cs);
}
@ -1760,14 +1760,14 @@ ovsdb_monitors_commit(struct ovsdb *db, const struct ovsdb_txn *txn)
void
ovsdb_monitors_remove(struct ovsdb *db)
{
struct ovsdb_monitor *m, *next_m;
struct ovsdb_monitor *m;
LIST_FOR_EACH_SAFE (m, next_m, list_node, &db->monitors) {
struct jsonrpc_monitor_node *jm, *next_jm;
LIST_FOR_EACH_SAFE (m, list_node, &db->monitors) {
struct jsonrpc_monitor_node *jm;
/* Delete all front-end monitors. Removing the last front-end monitor
* will also destroy the corresponding ovsdb_monitor. */
LIST_FOR_EACH_SAFE (jm, next_jm, node, &m->jsonrpc_monitors) {
LIST_FOR_EACH_SAFE (jm, node, &m->jsonrpc_monitors) {
ovsdb_jsonrpc_monitor_destroy(jm->jsonrpc_monitor, false);
}
}
@ -1789,14 +1789,14 @@ ovsdb_monitor_get_memory_usage(struct simap *usage)
void
ovsdb_monitor_prereplace_db(struct ovsdb *db)
{
struct ovsdb_monitor *m, *next_m;
struct ovsdb_monitor *m;
LIST_FOR_EACH_SAFE (m, next_m, list_node, &db->monitors) {
struct jsonrpc_monitor_node *jm, *next_jm;
LIST_FOR_EACH_SAFE (m, list_node, &db->monitors) {
struct jsonrpc_monitor_node *jm;
/* Delete all front-end monitors. Removing the last front-end monitor
* will also destroy the corresponding ovsdb_monitor. */
LIST_FOR_EACH_SAFE (jm, next_jm, node, &m->jsonrpc_monitors) {
LIST_FOR_EACH_SAFE (jm, node, &m->jsonrpc_monitors) {
ovsdb_jsonrpc_monitor_destroy(jm->jsonrpc_monitor, true);
}
}

4
ovsdb/ovsdb.c
View File

@ -571,8 +571,8 @@ ovsdb_replace(struct ovsdb *dst, struct ovsdb *src)
ovsdb_monitor_prereplace_db(dst);
/* Cancel triggers. */
struct ovsdb_trigger *trigger, *next;
LIST_FOR_EACH_SAFE (trigger, next, node, &dst->triggers) {
struct ovsdb_trigger *trigger;
LIST_FOR_EACH_SAFE (trigger, node, &dst->triggers) {
ovsdb_trigger_prereplace_db(trigger);
}

15
ovsdb/raft.c
View File

@ -1384,8 +1384,8 @@ raft_close__(struct raft *raft)
raft->remove_server = NULL;
}
struct raft_conn *conn, *next;
LIST_FOR_EACH_SAFE (conn, next, list_node, &raft->conns) {
struct raft_conn *conn;
LIST_FOR_EACH_SAFE (conn, list_node, &raft->conns) {
raft_conn_close(conn);
}
}
@ -1721,8 +1721,8 @@ raft_waiters_run(struct raft *raft)
}
uint64_t cur = ovsdb_log_commit_progress(raft->log);
struct raft_waiter *w, *next;
LIST_FOR_EACH_SAFE (w, next, list_node, &raft->waiters) {
struct raft_waiter *w;
LIST_FOR_EACH_SAFE (w, list_node, &raft->waiters) {
if (cur < w->commit_ticket) {
break;
}
@ -1744,8 +1744,8 @@ raft_waiters_wait(struct raft *raft)
static void
raft_waiters_destroy(struct raft *raft)
{
struct raft_waiter *w, *next;
LIST_FOR_EACH_SAFE (w, next, list_node, &raft->waiters) {
struct raft_waiter *w;
LIST_FOR_EACH_SAFE (w, list_node, &raft->waiters) {
raft_waiter_destroy(w);
}
}
@ -1968,8 +1968,7 @@ raft_run(struct raft *raft)
/* Close unneeded sessions. */
struct raft_server *server;
struct raft_conn *next;
LIST_FOR_EACH_SAFE (conn, next, list_node, &raft->conns) {
LIST_FOR_EACH_SAFE (conn, list_node, &raft->conns) {
if (!raft_conn_should_stay_open(raft, conn)) {
server = raft_find_new_server(raft, &conn->sid);
if (server) {

6
ovsdb/transaction-forward.c
View File

@ -126,10 +126,10 @@ ovsdb_txn_forward_steal_reply(struct ovsdb_txn_forward *txn_fwd)
void
ovsdb_txn_forward_run(struct ovsdb *db, struct ovsdb_cs *cs)
{
struct ovsdb_txn_forward *t, *next;
struct ovsdb_txn_forward *t;
/* Send all transactions that needs to be forwarded. */
LIST_FOR_EACH_SAFE (t, next, new_node, &db->txn_forward_new) {
LIST_FOR_EACH_SAFE (t, new_node, &db->txn_forward_new) {
if (!ovsdb_cs_may_send_transaction(cs)) {
break;
}
@ -177,7 +177,7 @@ ovsdb_txn_forward_cancel_all(struct ovsdb *db, bool sent_only)
return;
}
LIST_FOR_EACH_SAFE (t, next, new_node, &db->txn_forward_new) {
LIST_FOR_EACH_SAFE (t, new_node, &db->txn_forward_new) {
ovsdb_txn_forward_cancel(db, t);
}
}

28
ovsdb/transaction.c
View File

@ -159,15 +159,15 @@ ovsdb_txn_row_abort(struct ovsdb_txn *txn OVS_UNUSED,
hmap_replace(&new->table->rows, &new->hmap_node, &old->hmap_node);
}
struct ovsdb_weak_ref *weak, *next;
LIST_FOR_EACH_SAFE (weak, next, src_node, &txn_row->deleted_refs) {
struct ovsdb_weak_ref *weak;
LIST_FOR_EACH_SAFE (weak, src_node, &txn_row->deleted_refs) {
ovs_list_remove(&weak->src_node);
ovs_list_init(&weak->src_node);
if (hmap_node_is_null(&weak->dst_node)) {
ovsdb_weak_ref_destroy(weak);
}
}
LIST_FOR_EACH_SAFE (weak, next, src_node, &txn_row->added_refs) {
LIST_FOR_EACH_SAFE (weak, src_node, &txn_row->added_refs) {
ovs_list_remove(&weak->src_node);
ovs_list_init(&weak->src_node);
if (hmap_node_is_null(&weak->dst_node)) {
@ -508,11 +508,11 @@ static struct ovsdb_error *
ovsdb_txn_update_weak_refs(struct ovsdb_txn *txn OVS_UNUSED,
struct ovsdb_txn_row *txn_row)
{
struct ovsdb_weak_ref *weak, *next, *dst_weak;
struct ovsdb_weak_ref *weak, *dst_weak;
struct ovsdb_row *dst_row;
/* Find and clean up deleted references from destination rows. */
LIST_FOR_EACH_SAFE (weak, next, src_node, &txn_row->deleted_refs) {
LIST_FOR_EACH_SAFE (weak, src_node, &txn_row->deleted_refs) {
dst_row = CONST_CAST(struct ovsdb_row *,
ovsdb_table_get_row(weak->dst_table, &weak->dst));
if (dst_row) {
@ -529,7 +529,7 @@ ovsdb_txn_update_weak_refs(struct ovsdb_txn *txn OVS_UNUSED,
}
/* Insert the weak references added in the new version of the row. */
LIST_FOR_EACH_SAFE (weak, next, src_node, &txn_row->added_refs) {
LIST_FOR_EACH_SAFE (weak, src_node, &txn_row->added_refs) {
dst_row = CONST_CAST(struct ovsdb_row *,
ovsdb_table_get_row(weak->dst_table, &weak->dst));
@ -597,7 +597,7 @@ find_and_add_weak_ref(struct ovsdb_txn_row *txn_row,
static struct ovsdb_error * OVS_WARN_UNUSED_RESULT
assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row)
{
struct ovsdb_weak_ref *weak, *next;
struct ovsdb_weak_ref *weak;
struct ovsdb_table *table;
struct shash_node *node;
@ -642,7 +642,7 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row)
/* Collecting all key-value pairs that references deleted rows. */
ovsdb_datum_init_empty(&deleted_refs);
LIST_FOR_EACH_SAFE (weak, next, src_node, &txn_row->deleted_refs) {
LIST_FOR_EACH_SAFE (weak, src_node, &txn_row->deleted_refs) {
if (column->index == weak->column_idx) {
ovsdb_datum_add_unsafe(&deleted_refs, &weak->key, &weak->value,
&column->type, NULL);
@ -1094,8 +1094,8 @@ static void
ovsdb_txn_destroy_cloned(struct ovsdb_txn *txn)
{
ovs_assert(!txn->db);
struct ovsdb_txn_table *t, *next_txn_table;
LIST_FOR_EACH_SAFE (t, next_txn_table, node, &txn->txn_tables) {
struct ovsdb_txn_table *t;
LIST_FOR_EACH_SAFE (t, node, &txn->txn_tables) {
struct ovsdb_txn_row *r, *next_txn_row;
HMAP_FOR_EACH_SAFE (r, next_txn_row, hmap_node, &t->txn_rows) {
if (r->old) {
@ -1550,10 +1550,10 @@ for_each_txn_row(struct ovsdb_txn *txn,
serial++;
do {
struct ovsdb_txn_table *t, *next_txn_table;
struct ovsdb_txn_table *t;
any_work = false;
LIST_FOR_EACH_SAFE (t, next_txn_table, node, &txn->txn_tables) {
LIST_FOR_EACH_SAFE (t, node, &txn->txn_tables) {
if (t->serial != serial) {
t->serial = serial;
t->n_processed = 0;
@ -1630,8 +1630,8 @@ ovsdb_txn_history_destroy(struct ovsdb *db)
return;
}
struct ovsdb_txn_history_node *txn_h_node, *next;
LIST_FOR_EACH_SAFE (txn_h_node, next, node, &db->txn_history) {
struct ovsdb_txn_history_node *txn_h_node;
LIST_FOR_EACH_SAFE (txn_h_node, node, &db->txn_history) {
ovs_list_remove(&txn_h_node->node);
ovsdb_txn_destroy_cloned(txn_h_node->txn);
free(txn_h_node);

4
ovsdb/trigger.c
View File

@ -146,14 +146,14 @@ ovsdb_trigger_prereplace_db(struct ovsdb_trigger *trigger)
bool
ovsdb_trigger_run(struct ovsdb *db, long long int now)
{
struct ovsdb_trigger *t, *next;
struct ovsdb_trigger *t;
bool run_triggers = db->run_triggers;
db->run_triggers_now = db->run_triggers = false;
bool disconnect_all = false;
LIST_FOR_EACH_SAFE (t, next, node, &db->triggers) {
LIST_FOR_EACH_SAFE (t, node, &db->triggers) {
if (run_triggers
|| now - t->created >= t->timeout_msec
|| t->progress || t->txn_forward) {

29
tests/test-list.c
View File

@ -164,6 +164,35 @@ test_list_for_each_safe(void)
}
}
assert(n == n_remaining);
/* Test short version (without next variable). */
make_list(&list, elements, values, n);
i = 0;
values_idx = 0;
n_remaining = n;
LIST_FOR_EACH_SAFE (e, node, &list) {
assert(i < n);
if (pattern & (1ul << i)) {
ovs_list_remove(&e->node);
n_remaining--;
memmove(&values[values_idx], &values[values_idx + 1],
sizeof *values * (n_remaining - values_idx));
} else {
values_idx++;
}
check_list(&list, values, n_remaining);
i++;
}
assert(i == n);
assert(e == NULL);
for (i = 0; i < n; i++) {
if (pattern & (1ul << i)) {
n_remaining++;
}
}
}
}
}

4
utilities/ovs-ofctl.c
View File

@ -730,12 +730,12 @@ static void
bundle_print_errors(struct ovs_list *errors, struct ovs_list *requests,
const char *vconn_name)
{
struct ofpbuf *error, *next;
struct ofpbuf *error;
struct ofpbuf *bmsg;
INIT_CONTAINER(bmsg, requests, list_node);
LIST_FOR_EACH_SAFE (error, next, list_node, errors) {
LIST_FOR_EACH_SAFE (error, list_node, errors) {
const struct ofp_header *error_oh = error->data;
ovs_be32 error_xid = error_oh->xid;
enum ofperr ofperr;

8
utilities/ovs-vsctl.c
View File

@ -1510,13 +1510,13 @@ cmd_add_br(struct ctl_context *ctx)
static void
del_port(struct vsctl_context *vsctl_ctx, struct vsctl_port *port)
{
struct vsctl_iface *iface, *next_iface;
struct vsctl_iface *iface;
bridge_delete_port((port->bridge->parent
? port->bridge->parent->br_cfg
: port->bridge->br_cfg), port->port_cfg);
LIST_FOR_EACH_SAFE (iface, next_iface, ifaces_node, &port->ifaces) {
LIST_FOR_EACH_SAFE (iface, ifaces_node, &port->ifaces) {
del_cached_iface(vsctl_ctx, iface);
}
del_cached_port(vsctl_ctx, port);
@ -1526,14 +1526,14 @@ static void
del_bridge(struct vsctl_context *vsctl_ctx, struct vsctl_bridge *br)
{
struct vsctl_bridge *child, *next_child;
struct vsctl_port *port, *next_port;
struct vsctl_port *port;
const struct ovsrec_flow_sample_collector_set *fscset, *next_fscset;
HMAP_FOR_EACH_SAFE (child, next_child, children_node, &br->children) {
del_bridge(vsctl_ctx, child);
}
LIST_FOR_EACH_SAFE (port, next_port, ports_node, &br->ports) {
LIST_FOR_EACH_SAFE (port, ports_node, &br->ports) {
del_port(vsctl_ctx, port);
}

16
vswitchd/bridge.c
View File

@ -1133,9 +1133,9 @@ bridge_delete_or_reconfigure_ports(struct bridge *br)
* whose module was just unloaded via "rmmod", or a virtual NIC for a
* VM whose VM was just terminated. */
HMAP_FOR_EACH_SAFE (port, port_next, hmap_node, &br->ports) {
struct iface *iface, *iface_next;
struct iface *iface;
LIST_FOR_EACH_SAFE (iface, iface_next, port_elem, &port->ifaces) {
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
if (!sset_contains(&ofproto_ports, iface->name)) {
iface_destroy__(iface);
}
@ -4341,12 +4341,12 @@ static void
bridge_aa_refresh_queued(struct bridge *br)
{
struct ovs_list *list = xmalloc(sizeof *list);
struct bridge_aa_vlan *node, *next;
struct bridge_aa_vlan *node;
ovs_list_init(list);
ofproto_aa_vlan_get_queued(br->ofproto, list);
LIST_FOR_EACH_SAFE (node, next, list_node, list) {
LIST_FOR_EACH_SAFE (node, list_node, list) {
struct port *port;
VLOG_INFO("ifname=%s, vlan=%u, oper=%u", node->port_name, node->vlan,
@ -4387,7 +4387,7 @@ port_create(struct bridge *br, const struct ovsrec_port *cfg)
static void
port_del_ifaces(struct port *port)
{
struct iface *iface, *next;
struct iface *iface;
struct sset new_ifaces;
size_t i;
@ -4398,7 +4398,7 @@ port_del_ifaces(struct port *port)
}
/* Get rid of deleted interfaces. */
LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
if (!sset_contains(&new_ifaces, iface->name)) {
iface_destroy(iface);
}
@ -4412,13 +4412,13 @@ port_destroy(struct port *port)
{
if (port) {
struct bridge *br = port->bridge;
struct iface *iface, *next;
struct iface *iface;
if (br->ofproto) {
ofproto_bundle_unregister(br->ofproto, port);
}
LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
iface_destroy__(iface);
}

12
vtep/vtep-ctl.c
View File

@ -808,9 +808,9 @@ vtep_ctl_context_invalidate_cache(struct ctl_context *ctx)
SHASH_FOR_EACH_SAFE (node2, next_node2, &ls->mcast_local) {
struct vtep_ctl_mcast_mac *mcast_mac = node2->data;
struct vtep_ctl_ploc *ploc, *next_ploc;
struct vtep_ctl_ploc *ploc;
LIST_FOR_EACH_SAFE (ploc, next_ploc, locators_node,
LIST_FOR_EACH_SAFE (ploc, locators_node,
&mcast_mac->locators) {
free(ploc);
}
@ -820,9 +820,9 @@ vtep_ctl_context_invalidate_cache(struct ctl_context *ctx)
SHASH_FOR_EACH_SAFE (node2, next_node2, &ls->mcast_remote) {
struct vtep_ctl_mcast_mac *mcast_mac = node2->data;
struct vtep_ctl_ploc *ploc, *next_ploc;
struct vtep_ctl_ploc *ploc;
LIST_FOR_EACH_SAFE (ploc, next_ploc, locators_node,
LIST_FOR_EACH_SAFE (ploc, locators_node,
&mcast_mac->locators) {
free(ploc);
}
@ -1229,9 +1229,9 @@ del_port(struct vtep_ctl_context *vtepctl_ctx, struct vtep_ctl_port *port)
static void
del_pswitch(struct vtep_ctl_context *vtepctl_ctx, struct vtep_ctl_pswitch *ps)
{
struct vtep_ctl_port *port, *next_port;
struct vtep_ctl_port *port;
LIST_FOR_EACH_SAFE (port, next_port, ports_node, &ps->ports) {
LIST_FOR_EACH_SAFE (port, ports_node, &ps->ports) {
del_port(vtepctl_ctx, port);
}