Commit df0933dc authored by Patrick McHardy's avatar Patrick McHardy Committed by David S. Miller
Browse files

[NETFILTER]: kill listhelp.h 



Kill listhelp.h and use the list.h functions instead.

Signed-off-by: default avatarPatrick McHardy <kaber@trash.net>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 1bf38a36

include/linux/netfilter/x_tables.h

+0 −4
Original line number Diff line number Diff line
@@ -138,10 +138,6 @@ struct xt_counters_info 


#include <linux/netdevice.h>



#define ASSERT_READ_LOCK(x)

#define ASSERT_WRITE_LOCK(x)

#include <linux/netfilter_ipv4/listhelp.h>



#ifdef CONFIG_COMPAT

#define COMPAT_TO_USER		1

#define COMPAT_FROM_USER	-1

include/linux/netfilter_ipv4/listhelp.h

deleted100644 → 0
+0 −123
Original line number Diff line number Diff line 
#ifndef _LISTHELP_H

#define _LISTHELP_H

#include <linux/list.h>



/* Header to do more comprehensive job than linux/list.h; assume list

   is first entry in structure. */



/* Return pointer to first true entry, if any, or NULL.  A macro

   required to allow inlining of cmpfn. */

#define LIST_FIND(head, cmpfn, type, args...)		\

({							\

	const struct list_head *__i, *__j = NULL;	\

							\

	ASSERT_READ_LOCK(head);				\

	list_for_each(__i, (head))			\

		if (cmpfn((const type)__i , ## args)) {	\

			__j = __i;			\

			break;				\

		}					\

	(type)__j;					\

})



#define LIST_FIND_W(head, cmpfn, type, args...)		\

({							\

	const struct list_head *__i, *__j = NULL;	\

							\

	ASSERT_WRITE_LOCK(head);			\

	list_for_each(__i, (head))			\

		if (cmpfn((type)__i , ## args)) {	\

			__j = __i;			\

			break;				\

		}					\

	(type)__j;					\

})



/* Just like LIST_FIND but we search backwards */

#define LIST_FIND_B(head, cmpfn, type, args...)		\

({							\

	const struct list_head *__i, *__j = NULL;	\

							\

	ASSERT_READ_LOCK(head);				\

	list_for_each_prev(__i, (head))			\

		if (cmpfn((const type)__i , ## args)) {	\

			__j = __i;			\

			break;				\

		}					\

	(type)__j;					\

})



static inline int

__list_cmp_same(const void *p1, const void *p2) { return p1 == p2; }



/* Is this entry in the list? */

static inline int

list_inlist(struct list_head *head, const void *entry)

{

	return LIST_FIND(head, __list_cmp_same, void *, entry) != NULL;

}



/* Delete from list. */

#ifdef CONFIG_NETFILTER_DEBUG

#define LIST_DELETE(head, oldentry)					\

do {									\

	ASSERT_WRITE_LOCK(head);					\

	if (!list_inlist(head, oldentry))				\

		printk("LIST_DELETE: %s:%u `%s'(%p) not in %s.\n",	\

		       __FILE__, __LINE__, #oldentry, oldentry, #head);	\

        else list_del((struct list_head *)oldentry);			\

} while(0)

#else

#define LIST_DELETE(head, oldentry) list_del((struct list_head *)oldentry)

#endif



/* Append. */

static inline void

list_append(struct list_head *head, void *new)

{

	ASSERT_WRITE_LOCK(head);

	list_add((new), (head)->prev);

}



/* Prepend. */

static inline void

list_prepend(struct list_head *head, void *new)

{

	ASSERT_WRITE_LOCK(head);

	list_add(new, head);

}



/* Insert according to ordering function; insert before first true. */

#define LIST_INSERT(head, new, cmpfn)				\

do {								\

	struct list_head *__i;					\

	ASSERT_WRITE_LOCK(head);				\

	list_for_each(__i, (head))				\

		if ((new), (typeof (new))__i)			\

			break;					\

	list_add((struct list_head *)(new), __i->prev);		\

} while(0)



/* If the field after the list_head is a nul-terminated string, you

   can use these functions. */

static inline int __list_cmp_name(const void *i, const char *name)

{

	return strcmp(name, i+sizeof(struct list_head)) == 0;

}



/* Returns false if same name already in list, otherwise does insert. */

static inline int

list_named_insert(struct list_head *head, void *new)

{

	if (LIST_FIND(head, __list_cmp_name, void *,

		      new + sizeof(struct list_head)))

		return 0;

	list_prepend(head, new);

	return 1;

}



/* Find this named element in the list. */

#define list_named_find(head, name)			\

LIST_FIND(head, __list_cmp_name, void *, name)



#endif /*_LISTHELP_H*/

net/bridge/netfilter/ebtables.c

+45 −31
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <linux/vmalloc.h>

#include <linux/netfilter_bridge/ebtables.h>

#include <linux/spinlock.h>

#include <linux/mutex.h>

#include <asm/uaccess.h>

#include <linux/smp.h>

#include <linux/cpumask.h>
@@ -31,12 +32,6 @@ 
/* needed for logical [in,out]-dev filtering */

#include "../br_private.h"



/* list_named_find */

#define ASSERT_READ_LOCK(x)

#define ASSERT_WRITE_LOCK(x)

#include <linux/netfilter_ipv4/listhelp.h>

#include <linux/mutex.h>



#define BUGPRINT(format, args...) printk("kernel msg: ebtables bug: please "\

                                         "report to author: "format, ## args)

/* #define BUGPRINT(format, args...) */
@@ -278,18 +273,22 @@ static inline void * 
find_inlist_lock_noload(struct list_head *head, const char *name, int *error,

   struct mutex *mutex)

{

	void *ret;

	struct {

		struct list_head list;

		char name[EBT_FUNCTION_MAXNAMELEN];

	} *e;



	*error = mutex_lock_interruptible(mutex);

	if (*error != 0)

		return NULL;



	ret = list_named_find(head, name);

	if (!ret) {

	list_for_each_entry(e, head, list) {

		if (strcmp(e->name, name) == 0)

			return e;

	}

	*error = -ENOENT;

	mutex_unlock(mutex);

	}

	return ret;

	return NULL;

}



#ifndef CONFIG_KMOD
@@ -1043,15 +1042,19 @@ static int do_replace(void __user *user, unsigned int len) 


int ebt_register_target(struct ebt_target *target)

{

	struct ebt_target *t;

	int ret;



	ret = mutex_lock_interruptible(&ebt_mutex);

	if (ret != 0)

		return ret;

	if (!list_named_insert(&ebt_targets, target)) {

	list_for_each_entry(t, &ebt_targets, list) {

		if (strcmp(t->name, target->name) == 0) {

			mutex_unlock(&ebt_mutex);

			return -EEXIST;

		}

	}

	list_add(&target->list, &ebt_targets);

	mutex_unlock(&ebt_mutex);



	return 0;
@@ -1060,21 +1063,25 @@ int ebt_register_target(struct ebt_target *target) 
void ebt_unregister_target(struct ebt_target *target)

{

	mutex_lock(&ebt_mutex);

	LIST_DELETE(&ebt_targets, target);

	list_del(&target->list);

	mutex_unlock(&ebt_mutex);

}



int ebt_register_match(struct ebt_match *match)

{

	struct ebt_match *m;

	int ret;



	ret = mutex_lock_interruptible(&ebt_mutex);

	if (ret != 0)

		return ret;

	if (!list_named_insert(&ebt_matches, match)) {

	list_for_each_entry(m, &ebt_matches, list) {

		if (strcmp(m->name, match->name) == 0) {

			mutex_unlock(&ebt_mutex);

			return -EEXIST;

		}

	}

	list_add(&match->list, &ebt_matches);

	mutex_unlock(&ebt_mutex);



	return 0;
@@ -1083,21 +1090,25 @@ int ebt_register_match(struct ebt_match *match) 
void ebt_unregister_match(struct ebt_match *match)

{

	mutex_lock(&ebt_mutex);

	LIST_DELETE(&ebt_matches, match);

	list_del(&match->list);

	mutex_unlock(&ebt_mutex);

}



int ebt_register_watcher(struct ebt_watcher *watcher)

{

	struct ebt_watcher *w;

	int ret;



	ret = mutex_lock_interruptible(&ebt_mutex);

	if (ret != 0)

		return ret;

	if (!list_named_insert(&ebt_watchers, watcher)) {

	list_for_each_entry(w, &ebt_watchers, list) {

		if (strcmp(w->name, watcher->name) == 0) {

			mutex_unlock(&ebt_mutex);

			return -EEXIST;

		}

	}

	list_add(&watcher->list, &ebt_watchers);

	mutex_unlock(&ebt_mutex);



	return 0;
@@ -1106,13 +1117,14 @@ int ebt_register_watcher(struct ebt_watcher *watcher) 
void ebt_unregister_watcher(struct ebt_watcher *watcher)

{

	mutex_lock(&ebt_mutex);

	LIST_DELETE(&ebt_watchers, watcher);

	list_del(&watcher->list);

	mutex_unlock(&ebt_mutex);

}



int ebt_register_table(struct ebt_table *table)

{

	struct ebt_table_info *newinfo;

	struct ebt_table *t;

	int ret, i, countersize;



	if (!table || !table->table ||!table->table->entries ||
@@ -1158,18 +1170,20 @@ int ebt_register_table(struct ebt_table *table) 
	if (ret != 0)

		goto free_chainstack;



	if (list_named_find(&ebt_tables, table->name)) {

	list_for_each_entry(t, &ebt_tables, list) {

		if (strcmp(t->name, table->name) == 0) {

			ret = -EEXIST;

			BUGPRINT("Table name already exists\n");

			goto free_unlock;

		}

	}



	/* Hold a reference count if the chains aren't empty */

	if (newinfo->nentries && !try_module_get(table->me)) {

		ret = -ENOENT;

		goto free_unlock;

	}

	list_prepend(&ebt_tables, table);

	list_add(&table->list, &ebt_tables);

	mutex_unlock(&ebt_mutex);

	return 0;

free_unlock:
@@ -1195,7 +1209,7 @@ void ebt_unregister_table(struct ebt_table *table) 
		return;

	}

	mutex_lock(&ebt_mutex);

	LIST_DELETE(&ebt_tables, table);

	list_del(&table->list);

	mutex_unlock(&ebt_mutex);

	vfree(table->private->entries);

	if (table->private->chainstack) {
@@ -1465,7 +1479,7 @@ static int __init ebtables_init(void) 
	int ret;



	mutex_lock(&ebt_mutex);

	list_named_insert(&ebt_targets, &ebt_standard_target);

	list_add(&ebt_standard_target.list, &ebt_targets);

	mutex_unlock(&ebt_mutex);

	if ((ret = nf_register_sockopt(&ebt_sockopts)) < 0)

		return ret;

net/ipv4/netfilter/arp_tables.c

+0 −2
Original line number Diff line number Diff line
@@ -56,8 +56,6 @@ do { \ 
#define ARP_NF_ASSERT(x)

#endif



#include <linux/netfilter_ipv4/listhelp.h>



static inline int arp_devaddr_compare(const struct arpt_devaddr_info *ap,

				      char *hdr_addr, int len)

{

net/ipv4/netfilter/ip_conntrack_core.c

+85 −104
Original line number Diff line number Diff line
@@ -47,7 +47,6 @@ 
#include <linux/netfilter_ipv4/ip_conntrack_protocol.h>

#include <linux/netfilter_ipv4/ip_conntrack_helper.h>

#include <linux/netfilter_ipv4/ip_conntrack_core.h>

#include <linux/netfilter_ipv4/listhelp.h>



#define IP_CONNTRACK_VERSION	"2.4"
@@ -294,15 +293,10 @@ void ip_ct_remove_expectations(struct ip_conntrack *ct) 
static void

clean_from_lists(struct ip_conntrack *ct)

{

	unsigned int ho, hr;

	

	DEBUGP("clean_from_lists(%p)\n", ct);

	ASSERT_WRITE_LOCK(&ip_conntrack_lock);



	ho = hash_conntrack(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);

	hr = hash_conntrack(&ct->tuplehash[IP_CT_DIR_REPLY].tuple);

	LIST_DELETE(&ip_conntrack_hash[ho], &ct->tuplehash[IP_CT_DIR_ORIGINAL]);

	LIST_DELETE(&ip_conntrack_hash[hr], &ct->tuplehash[IP_CT_DIR_REPLY]);

	list_del(&ct->tuplehash[IP_CT_DIR_ORIGINAL].list);

	list_del(&ct->tuplehash[IP_CT_DIR_REPLY].list);



	/* Destroy all pending expectations */

	ip_ct_remove_expectations(ct);
@@ -367,16 +361,6 @@ static void death_by_timeout(unsigned long ul_conntrack) 
	ip_conntrack_put(ct);

}



static inline int

conntrack_tuple_cmp(const struct ip_conntrack_tuple_hash *i,

		    const struct ip_conntrack_tuple *tuple,

		    const struct ip_conntrack *ignored_conntrack)

{

	ASSERT_READ_LOCK(&ip_conntrack_lock);

	return tuplehash_to_ctrack(i) != ignored_conntrack

		&& ip_ct_tuple_equal(tuple, &i->tuple);

}



struct ip_conntrack_tuple_hash *

__ip_conntrack_find(const struct ip_conntrack_tuple *tuple,

		    const struct ip_conntrack *ignored_conntrack)
@@ -386,7 +370,8 @@ __ip_conntrack_find(const struct ip_conntrack_tuple *tuple, 


	ASSERT_READ_LOCK(&ip_conntrack_lock);

	list_for_each_entry(h, &ip_conntrack_hash[hash], list) {

		if (conntrack_tuple_cmp(h, tuple, ignored_conntrack)) {

		if (tuplehash_to_ctrack(h) != ignored_conntrack &&

		    ip_ct_tuple_equal(tuple, &h->tuple)) {

			CONNTRACK_STAT_INC(found);

			return h;

		}
@@ -417,10 +402,10 @@ static void __ip_conntrack_hash_insert(struct ip_conntrack *ct, 
					unsigned int repl_hash) 

{

	ct->id = ++ip_conntrack_next_id;

	list_prepend(&ip_conntrack_hash[hash],

		     &ct->tuplehash[IP_CT_DIR_ORIGINAL].list);

	list_prepend(&ip_conntrack_hash[repl_hash],

		     &ct->tuplehash[IP_CT_DIR_REPLY].list);

	list_add(&ct->tuplehash[IP_CT_DIR_ORIGINAL].list,

		 &ip_conntrack_hash[hash]);

	list_add(&ct->tuplehash[IP_CT_DIR_REPLY].list,

		 &ip_conntrack_hash[repl_hash]);

}



void ip_conntrack_hash_insert(struct ip_conntrack *ct)
@@ -440,6 +425,7 @@ int 
__ip_conntrack_confirm(struct sk_buff **pskb)

{

	unsigned int hash, repl_hash;

	struct ip_conntrack_tuple_hash *h;

	struct ip_conntrack *ct;

	enum ip_conntrack_info ctinfo;
@@ -470,14 +456,15 @@ __ip_conntrack_confirm(struct sk_buff **pskb) 
	/* See if there's one in the list already, including reverse:

           NAT could have grabbed it without realizing, since we're

           not in the hash.  If there is, we lost race. */

	if (!LIST_FIND(&ip_conntrack_hash[hash],

		       conntrack_tuple_cmp,

		       struct ip_conntrack_tuple_hash *,

		       &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple, NULL)

	    && !LIST_FIND(&ip_conntrack_hash[repl_hash],

			  conntrack_tuple_cmp,

			  struct ip_conntrack_tuple_hash *,

			  &ct->tuplehash[IP_CT_DIR_REPLY].tuple, NULL)) {

	list_for_each_entry(h, &ip_conntrack_hash[hash], list)

		if (ip_ct_tuple_equal(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,

				      &h->tuple))

			goto out;

	list_for_each_entry(h, &ip_conntrack_hash[repl_hash], list)

		if (ip_ct_tuple_equal(&ct->tuplehash[IP_CT_DIR_REPLY].tuple,

				      &h->tuple))

			goto out;



	/* Remove from unconfirmed list */

	list_del(&ct->tuplehash[IP_CT_DIR_ORIGINAL].list);
@@ -502,11 +489,10 @@ __ip_conntrack_confirm(struct sk_buff **pskb) 
				 IPCT_RELATED : IPCT_NEW, *pskb);



	return NF_ACCEPT;

	}



out:

	CONNTRACK_STAT_INC(insert_failed);

	write_unlock_bh(&ip_conntrack_lock);



	return NF_DROP;

}
@@ -527,23 +513,21 @@ ip_conntrack_tuple_taken(const struct ip_conntrack_tuple *tuple, 


/* There's a small race here where we may free a just-assured

   connection.  Too bad: we're in trouble anyway. */

static inline int unreplied(const struct ip_conntrack_tuple_hash *i)

{

	return !(test_bit(IPS_ASSURED_BIT, &tuplehash_to_ctrack(i)->status));

}



static int early_drop(struct list_head *chain)

{

	/* Traverse backwards: gives us oldest, which is roughly LRU */

	struct ip_conntrack_tuple_hash *h;

	struct ip_conntrack *ct = NULL;

	struct ip_conntrack *ct = NULL, *tmp;

	int dropped = 0;



	read_lock_bh(&ip_conntrack_lock);

	h = LIST_FIND_B(chain, unreplied, struct ip_conntrack_tuple_hash *);

	if (h) {

		ct = tuplehash_to_ctrack(h);

	list_for_each_entry_reverse(h, chain, list) {

		tmp = tuplehash_to_ctrack(h);

		if (!test_bit(IPS_ASSURED_BIT, &tmp->status)) {

			ct = tmp;

			atomic_inc(&ct->ct_general.use);

			break;

		}

	}

	read_unlock_bh(&ip_conntrack_lock);
@@ -559,18 +543,16 @@ static int early_drop(struct list_head *chain) 
	return dropped;

}



static inline int helper_cmp(const struct ip_conntrack_helper *i,

			     const struct ip_conntrack_tuple *rtuple)

{

	return ip_ct_tuple_mask_cmp(rtuple, &i->tuple, &i->mask);

}



static struct ip_conntrack_helper *

__ip_conntrack_helper_find( const struct ip_conntrack_tuple *tuple)

{

	return LIST_FIND(&helpers, helper_cmp,

			 struct ip_conntrack_helper *,

			 tuple);

	struct ip_conntrack_helper *h;



	list_for_each_entry(h, &helpers, list) {

		if (ip_ct_tuple_mask_cmp(tuple, &h->tuple, &h->mask))

			return h;

	}

	return NULL;

}



struct ip_conntrack_helper *
@@ -1062,7 +1044,7 @@ int ip_conntrack_helper_register(struct ip_conntrack_helper *me) 
{

	BUG_ON(me->timeout == 0);

	write_lock_bh(&ip_conntrack_lock);

	list_prepend(&helpers, me);

	list_add(&me->list, &helpers);

	write_unlock_bh(&ip_conntrack_lock);



	return 0;
@@ -1081,24 +1063,24 @@ __ip_conntrack_helper_find_byname(const char *name) 
	return NULL;

}



static inline int unhelp(struct ip_conntrack_tuple_hash *i,

static inline void unhelp(struct ip_conntrack_tuple_hash *i,

			  const struct ip_conntrack_helper *me)

{

	if (tuplehash_to_ctrack(i)->helper == me) {

 		ip_conntrack_event(IPCT_HELPER, tuplehash_to_ctrack(i));

		tuplehash_to_ctrack(i)->helper = NULL;

	}

	return 0;

}



void ip_conntrack_helper_unregister(struct ip_conntrack_helper *me)

{

	unsigned int i;

	struct ip_conntrack_tuple_hash *h;

	struct ip_conntrack_expect *exp, *tmp;



	/* Need write lock here, to delete helper. */

	write_lock_bh(&ip_conntrack_lock);

	LIST_DELETE(&helpers, me);

	list_del(&me->list);



	/* Get rid of expectations */

	list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list, list) {
@@ -1108,10 +1090,12 @@ void ip_conntrack_helper_unregister(struct ip_conntrack_helper *me) 
		}

	}

	/* Get rid of expecteds, set helpers to NULL. */

	LIST_FIND_W(&unconfirmed, unhelp, struct ip_conntrack_tuple_hash*, me);

	for (i = 0; i < ip_conntrack_htable_size; i++)

		LIST_FIND_W(&ip_conntrack_hash[i], unhelp,

			    struct ip_conntrack_tuple_hash *, me);

	list_for_each_entry(h, &unconfirmed, list)

		unhelp(h, me);

	for (i = 0; i < ip_conntrack_htable_size; i++) {

		list_for_each_entry(h, &ip_conntrack_hash[i], list)

			unhelp(h, me);

	}

	write_unlock_bh(&ip_conntrack_lock);



	/* Someone could be still looking at the helper in a bh. */
@@ -1237,46 +1221,43 @@ static void ip_conntrack_attach(struct sk_buff *nskb, struct sk_buff *skb) 
	nf_conntrack_get(nskb->nfct);

}



static inline int

do_iter(const struct ip_conntrack_tuple_hash *i,

	int (*iter)(struct ip_conntrack *i, void *data),

	void *data)

{

	return iter(tuplehash_to_ctrack(i), data);

}



/* Bring out ya dead! */

static struct ip_conntrack_tuple_hash *

static struct ip_conntrack *

get_next_corpse(int (*iter)(struct ip_conntrack *i, void *data),

		void *data, unsigned int *bucket)

{

	struct ip_conntrack_tuple_hash *h = NULL;

	struct ip_conntrack_tuple_hash *h;

	struct ip_conntrack *ct;



	write_lock_bh(&ip_conntrack_lock);

	for (; *bucket < ip_conntrack_htable_size; (*bucket)++) {

		h = LIST_FIND_W(&ip_conntrack_hash[*bucket], do_iter,

				struct ip_conntrack_tuple_hash *, iter, data);

		if (h)

			break;

		list_for_each_entry(h, &ip_conntrack_hash[*bucket], list) {

			ct = tuplehash_to_ctrack(h);

			if (iter(ct, data))

				goto found;

		}

	}

	list_for_each_entry(h, &unconfirmed, list) {

		ct = tuplehash_to_ctrack(h);

		if (iter(ct, data))

			goto found;

	}

	if (!h)

		h = LIST_FIND_W(&unconfirmed, do_iter,

				struct ip_conntrack_tuple_hash *, iter, data);

	if (h)

		atomic_inc(&tuplehash_to_ctrack(h)->ct_general.use);

	write_unlock_bh(&ip_conntrack_lock);

	return NULL;



	return h;

found:

	atomic_inc(&ct->ct_general.use);

	write_unlock_bh(&ip_conntrack_lock);

	return ct;

}



void

ip_ct_iterate_cleanup(int (*iter)(struct ip_conntrack *i, void *), void *data)

{

	struct ip_conntrack_tuple_hash *h;

	struct ip_conntrack *ct;

	unsigned int bucket = 0;



	while ((h = get_next_corpse(iter, data, &bucket)) != NULL) {

		struct ip_conntrack *ct = tuplehash_to_ctrack(h);

	while ((ct = get_next_corpse(iter, data, &bucket)) != NULL) {

		/* Time to push up daises... */

		if (del_timer(&ct->timeout))

			death_by_timeout((unsigned long)ct);