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 <dce...@redhat.com>
> Signed-off-by: Adrian Moreno <amore...@redhat.com>
Other than some small nits below, the patch looks good to me.
Acked-by: Eelco Chaudron <echau...@redhat.com>
> ---
> 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?
> +/* 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
> d...@openvswitch.org
> https://mail.openvswitch.org/mailman/listinfo/ovs-dev
_______________________________________________
dev mailing list
d...@openvswitch.org
https://mail.openvswitch.org/mailman/listinfo/ovs-dev
