@@ -92,7 +92,8 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
CONDITION_MULTIVAR(VAR, MEMBER, ITER_VAR(VAR) != (LIST)); \
UPDATE_MULTIVAR(VAR, ITER_VAR(VAR)->prev))
-#define LIST_FOR_EACH_REVERSE_SAFE(VAR, PREV, MEMBER, LIST) \
+/* LONG version of SAFE iterators. */
+#define LIST_FOR_EACH_REVERSE_SAFE_LONG(VAR, PREV, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_LONG(VAR, PREV, MEMBER, (LIST)->prev, \
struct ovs_list); \
CONDITION_MULTIVAR_SAFE_LONG(VAR, PREV, MEMBER, \
@@ -101,7 +102,7 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
ITER_VAR(PREV) != (LIST)); \
UPDATE_MULTIVAR_SAFE_LONG(VAR, PREV))
-#define LIST_FOR_EACH_SAFE(VAR, NEXT, MEMBER, LIST) \
+#define LIST_FOR_EACH_SAFE_LONG(VAR, NEXT, MEMBER, LIST) \
for (INIT_MULTIVAR_SAFE_LONG(VAR, NEXT, MEMBER, (LIST)->next, \
struct ovs_list); \
CONDITION_MULTIVAR_SAFE_LONG(VAR, NEXT, MEMBER, \
@@ -110,6 +111,31 @@ static inline bool ovs_list_is_short(const struct ovs_list *);
ITER_VAR(NEXT) != (LIST)); \
UPDATE_MULTIVAR_SAFE_LONG(VAR, NEXT))
+/* SHORT version of SAFE iterators. */
+#define LIST_FOR_EACH_REVERSE_SAFE_SHORT(VAR, MEMBER, LIST) \
+ for (INIT_MULTIVAR_SAFE_SHORT(VAR, MEMBER, (LIST)->prev, struct ovs_list);\
+ CONDITION_MULTIVAR_SAFE_SHORT(VAR, MEMBER, \
+ ITER_VAR(VAR) != (LIST), \
+ ITER_NEXT_VAR(VAR) = ITER_VAR(VAR)->prev); \
+ UPDATE_MULTIVAR_SAFE_SHORT(VAR))
+
+#define LIST_FOR_EACH_SAFE_SHORT(VAR, MEMBER, LIST) \
+ for (INIT_MULTIVAR_SAFE_SHORT(VAR, MEMBER, (LIST)->next, struct ovs_list);\
+ CONDITION_MULTIVAR_SAFE_SHORT(VAR, MEMBER, \
+ ITER_VAR(VAR) != (LIST), \
+ ITER_NEXT_VAR(VAR) = ITER_VAR(VAR)->next); \
+ UPDATE_MULTIVAR_SAFE_SHORT(VAR))
+
+#define LIST_FOR_EACH_SAFE(...) \
+ OVERLOAD_SAFE_MACRO(LIST_FOR_EACH_SAFE_LONG, \
+ LIST_FOR_EACH_SAFE_SHORT, \
+ 4, __VA_ARGS__)
+
+#define LIST_FOR_EACH_REVERSE_SAFE(...) \
+ OVERLOAD_SAFE_MACRO(LIST_FOR_EACH_REVERSE_SAFE_LONG, \
+ LIST_FOR_EACH_REVERSE_SAFE_SHORT, \
+ 4, __VA_ARGS__)
+
#define LIST_FOR_EACH_POP(ITER, MEMBER, LIST) \
while (!ovs_list_is_empty(LIST) ? \
(INIT_CONTAINER(ITER, ovs_list_pop_front(LIST), MEMBER), 1) : \
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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;
@@ -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);
@@ -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);
@@ -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);
@@ -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);
}
@@ -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);
@@ -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);
}
@@ -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)) {
@@ -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);
}
@@ -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) {
@@ -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);
}
}
@@ -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;
@@ -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);
}
@@ -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);
}
@@ -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);
@@ -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);
}
}
@@ -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);
}
}
@@ -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);
}
@@ -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) {
@@ -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);
}
}
@@ -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);
@@ -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) {
@@ -164,6 +164,35 @@ test_list_for_each_safe(void)
}
}
assert(n == n_remaining);
+
+ /* Test short version (without next variable). */
+ make_list(&list, elements, values, n);
+
+ i = 0;
+ values_idx = 0;
+ n_remaining = n;
+ LIST_FOR_EACH_SAFE (e, node, &list) {
+ assert(i < n);
+ if (pattern & (1ul << i)) {
+ ovs_list_remove(&e->node);
+ n_remaining--;
+ memmove(&values[values_idx], &values[values_idx + 1],
+ sizeof *values * (n_remaining - values_idx));
+ } else {
+ values_idx++;
+ }
+
+ check_list(&list, values, n_remaining);
+ i++;
+ }
+ assert(i == n);
+ assert(e == NULL);
+
+ for (i = 0; i < n; i++) {
+ if (pattern & (1ul << i)) {
+ n_remaining++;
+ }
+ }
}
}
}
@@ -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;
@@ -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);
}
@@ -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);
}
@@ -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);
}