On 18 Mar 2022, at 14:38, Eelco Chaudron wrote:
> On 9 Mar 2022, at 17:10, Adrian Moreno wrote: > >> 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 <[email protected]> >> Signed-off-by: Adrian Moreno <[email protected]> > > Other than some small nits below, the patch looks good to me. > > > Acked-by: Eelco Chaudron <[email protected]> > >> --- >> include/openvswitch/list.h | 30 ++++++++++++++++++++++++++++-- >> lib/conntrack.c | 4 ++-- >> lib/fat-rwlock.c | 4 ++-- >> lib/id-fpool.c | 3 +-- >> lib/ipf.c | 22 +++++++++++----------- >> lib/lldp/lldpd-structs.c | 7 +++---- >> lib/lldp/lldpd.c | 8 ++++---- >> lib/mcast-snooping.c | 12 ++++++------ >> lib/netdev-afxdp.c | 4 ++-- >> lib/netdev-dpdk.c | 4 ++-- >> lib/ofp-msgs.c | 4 ++-- >> lib/ovs-lldp.c | 12 ++++++------ >> lib/ovsdb-idl.c | 30 +++++++++++++++--------------- >> lib/seq.c | 4 ++-- >> lib/tnl-ports.c | 16 ++++++++-------- >> lib/unixctl.c | 8 ++++---- >> lib/vconn.c | 4 ++-- >> ofproto/connmgr.c | 8 ++++---- >> ofproto/ofproto-dpif-ipfix.c | 4 ++-- >> ofproto/ofproto-dpif-trace.c | 4 ++-- >> ofproto/ofproto-dpif-xlate.c | 4 ++-- >> ofproto/ofproto-dpif.c | 24 +++++++++++------------- >> ovsdb/jsonrpc-server.c | 16 ++++++++-------- >> ovsdb/monitor.c | 24 ++++++++++++------------ >> ovsdb/ovsdb.c | 4 ++-- >> ovsdb/raft.c | 15 +++++++-------- >> ovsdb/transaction-forward.c | 6 +++--- >> ovsdb/transaction.c | 28 ++++++++++++++-------------- >> ovsdb/trigger.c | 4 ++-- >> tests/test-list.c | 29 +++++++++++++++++++++++++++++ >> utilities/ovs-ofctl.c | 4 ++-- >> utilities/ovs-vsctl.c | 8 ++++---- >> vswitchd/bridge.c | 16 ++++++++-------- >> vtep/vtep-ctl.c | 12 ++++++------ >> 34 files changed, 218 insertions(+), 168 deletions(-) >> >> diff --git a/include/openvswitch/list.h b/include/openvswitch/list.h >> index bbd2edbd0..6a7d4b2ff 100644 >> --- a/include/openvswitch/list.h >> +++ b/include/openvswitch/list.h >> @@ -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 */ > > Ending sentence with a dot. > >> +#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)) > > Do we really want to keep this MACRO as it’s not being used anywhere? Ignore this one, as it was Friday afternoon ;) >> +/* SHORT version of SAFE iterators */ > > Ending sentence with a dot. > >> +#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) : >> \ >> diff --git a/lib/conntrack.c b/lib/conntrack.c >> index 40690e5f0..4e2eb2932 100644 >> --- a/lib/conntrack.c >> +++ b/lib/conntrack.c >> @@ -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); >> diff --git a/lib/fat-rwlock.c b/lib/fat-rwlock.c >> index d913b2088..771ccc973 100644 >> --- a/lib/fat-rwlock.c >> +++ b/lib/fat-rwlock.c >> @@ -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); >> diff --git a/lib/id-fpool.c b/lib/id-fpool.c >> index 15cef5d00..7108c104a 100644 >> --- a/lib/id-fpool.c >> +++ b/lib/id-fpool.c >> @@ -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); >> diff --git a/lib/ipf.c b/lib/ipf.c >> index 507db2aea..d45266374 100644 >> --- a/lib/ipf.c >> +++ b/lib/ipf.c >> @@ -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); >> diff --git a/lib/lldp/lldpd-structs.c b/lib/lldp/lldpd-structs.c >> index 499b44174..a8c7fad09 100644 >> --- a/lib/lldp/lldpd-structs.c >> +++ b/lib/lldp/lldpd-structs.c >> @@ -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); >> diff --git a/lib/lldp/lldpd.c b/lib/lldp/lldpd.c >> index a024dc5e5..403f1f525 100644 >> --- a/lib/lldp/lldpd.c >> +++ b/lib/lldp/lldpd.c >> @@ -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); >> diff --git a/lib/mcast-snooping.c b/lib/mcast-snooping.c >> index 6730301b6..029ca2855 100644 >> --- a/lib/mcast-snooping.c >> +++ b/lib/mcast-snooping.c >> @@ -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; >> diff --git a/lib/netdev-afxdp.c b/lib/netdev-afxdp.c >> index 482400d8d..ca3f2431e 100644 >> --- a/lib/netdev-afxdp.c >> +++ b/lib/netdev-afxdp.c >> @@ -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); >> diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c >> index fbc3b42d8..2dd95a4cc 100644 >> --- a/lib/netdev-dpdk.c >> +++ b/lib/netdev-dpdk.c >> @@ -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); >> diff --git a/lib/ofp-msgs.c b/lib/ofp-msgs.c >> index fec54f75f..8f969ee59 100644 >> --- a/lib/ofp-msgs.c >> +++ b/lib/ofp-msgs.c >> @@ -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); >> diff --git a/lib/ovs-lldp.c b/lib/ovs-lldp.c >> index 162311fa4..a9d205ec8 100644 >> --- a/lib/ovs-lldp.c >> +++ b/lib/ovs-lldp.c >> @@ -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); >> } >> diff --git a/lib/ovsdb-idl.c b/lib/ovsdb-idl.c >> index c19128d55..13e086358 100644 >> --- a/lib/ovsdb-idl.c >> +++ b/lib/ovsdb-idl.c >> @@ -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); >> diff --git a/lib/seq.c b/lib/seq.c >> index 6581cb06b..2434ccb5d 100644 >> --- a/lib/seq.c >> +++ b/lib/seq.c >> @@ -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); >> } >> diff --git a/lib/tnl-ports.c b/lib/tnl-ports.c >> index 58269d3b1..f9fee3793 100644 >> --- a/lib/tnl-ports.c >> +++ b/lib/tnl-ports.c >> @@ -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)) { >> diff --git a/lib/unixctl.c b/lib/unixctl.c >> index 69aed6722..103357ee9 100644 >> --- a/lib/unixctl.c >> +++ b/lib/unixctl.c >> @@ -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); >> } >> >> diff --git a/lib/vconn.c b/lib/vconn.c >> index 7415e6291..b55676227 100644 >> --- a/lib/vconn.c >> +++ b/lib/vconn.c >> @@ -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) { >> diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c >> index fa8f6cd0e..5666d7283 100644 >> --- a/ofproto/connmgr.c >> +++ b/ofproto/connmgr.c >> @@ -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); >> } >> } >> diff --git a/ofproto/ofproto-dpif-ipfix.c b/ofproto/ofproto-dpif-ipfix.c >> index 9280e008e..ff4b6339a 100644 >> --- a/ofproto/ofproto-dpif-ipfix.c >> +++ b/ofproto/ofproto-dpif-ipfix.c >> @@ -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; >> diff --git a/ofproto/ofproto-dpif-trace.c b/ofproto/ofproto-dpif-trace.c >> index 78a54c715..109940ad2 100644 >> --- a/ofproto/ofproto-dpif-trace.c >> +++ b/ofproto/ofproto-dpif-trace.c >> @@ -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); >> } >> diff --git a/ofproto/ofproto-dpif-xlate.c b/ofproto/ofproto-dpif-xlate.c >> index cc9c1c628..922e02e97 100644 >> --- a/ofproto/ofproto-dpif-xlate.c >> +++ b/ofproto/ofproto-dpif-xlate.c >> @@ -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); >> } >> >> diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c >> index a4c44052d..9d4d55afb 100644 >> --- a/ofproto/ofproto-dpif.c >> +++ b/ofproto/ofproto-dpif.c >> @@ -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); >> diff --git a/ovsdb/jsonrpc-server.c b/ovsdb/jsonrpc-server.c >> index 351c39d8a..d091602d5 100644 >> --- a/ovsdb/jsonrpc-server.c >> +++ b/ovsdb/jsonrpc-server.c >> @@ -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); >> } >> } >> diff --git a/ovsdb/monitor.c b/ovsdb/monitor.c >> index 0f222cc99..513f37b1b 100644 >> --- a/ovsdb/monitor.c >> +++ b/ovsdb/monitor.c >> @@ -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); >> } >> } >> diff --git a/ovsdb/ovsdb.c b/ovsdb/ovsdb.c >> index e6d866182..91b4a01af 100644 >> --- a/ovsdb/ovsdb.c >> +++ b/ovsdb/ovsdb.c >> @@ -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); >> } >> >> diff --git a/ovsdb/raft.c b/ovsdb/raft.c >> index 855404808..23a2728f3 100644 >> --- a/ovsdb/raft.c >> +++ b/ovsdb/raft.c >> @@ -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) { >> diff --git a/ovsdb/transaction-forward.c b/ovsdb/transaction-forward.c >> index d15f2f1d6..4549e3427 100644 >> --- a/ovsdb/transaction-forward.c >> +++ b/ovsdb/transaction-forward.c >> @@ -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); >> } >> } >> diff --git a/ovsdb/transaction.c b/ovsdb/transaction.c >> index 090068603..3b96a3a14 100644 >> --- a/ovsdb/transaction.c >> +++ b/ovsdb/transaction.c >> @@ -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); >> diff --git a/ovsdb/trigger.c b/ovsdb/trigger.c >> index 726c138bf..7d3003bca 100644 >> --- a/ovsdb/trigger.c >> +++ b/ovsdb/trigger.c >> @@ -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) { >> diff --git a/tests/test-list.c b/tests/test-list.c >> index 7c02ea40f..e2edcbfd1 100644 >> --- a/tests/test-list.c >> +++ b/tests/test-list.c >> @@ -164,6 +164,35 @@ test_list_for_each_safe(void) >> } >> } >> assert(n == n_remaining); >> + >> + /* Test short version (without next variable) */ > > Ending sentence with a dot. > >> + 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++; >> + } >> + } >> } >> } >> } >> diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c >> index ede7f1e61..6771973ae 100644 >> --- a/utilities/ovs-ofctl.c >> +++ b/utilities/ovs-ofctl.c >> @@ -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; >> diff --git a/utilities/ovs-vsctl.c b/utilities/ovs-vsctl.c >> index 37cc72d40..812455eea 100644 >> --- a/utilities/ovs-vsctl.c >> +++ b/utilities/ovs-vsctl.c >> @@ -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); >> } >> >> diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c >> index 5223aa897..b1bc51bd5 100644 >> --- a/vswitchd/bridge.c >> +++ b/vswitchd/bridge.c >> @@ -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); >> } >> >> diff --git a/vtep/vtep-ctl.c b/vtep/vtep-ctl.c >> index ab552457d..3465d899b 100644 >> --- a/vtep/vtep-ctl.c >> +++ b/vtep/vtep-ctl.c >> @@ -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); >> } >> >> -- >> 2.34.1 >> >> _______________________________________________ >> dev mailing list >> [email protected] >> https://mail.openvswitch.org/mailman/listinfo/ovs-dev _______________________________________________ dev mailing list [email protected] https://mail.openvswitch.org/mailman/listinfo/ovs-dev
