A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-29 19:21:31 -04:00
Code Issues Projects Releases Packages Wiki Activity

[INET]: Consolidate xxx_find() in fragment management

Browse source 
Here we need another callback ->match to check whether the
entry found in hash matches the key passed. The key used 
is the same as the creation argument for inet_frag_create.

Yet again, this ->match is the same for netfilter and ipv6.
Running a frew steps forward - this callback will later
replace the ->equal one.

Since the inet_frag_find() uses the already consolidated
inet_frag_create() remove the xxx_frag_create from protocol
codes.

Signed-off-by: Pavel Emelyanov <[email protected]>
Signed-off-by: David S. Miller <[email protected]>
This commit is contained in:
Pavel Emelyanov 2007-10-17 19:47:21 -07:00 • committed by David S. Miller
commit abd6523d15
6 changed files with 73 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

25
net/ipv4/inet_fragment.c
View file

@ -226,8 +226,8 @@ static struct inet_frag_queue *inet_frag_alloc(struct inet_frags *f, void *arg)
return q;
}
struct inet_frag_queue *inet_frag_create(struct inet_frags *f, void *arg,
unsigned int hash)
static struct inet_frag_queue *inet_frag_create(struct inet_frags *f,
void *arg, unsigned int hash)
{
struct inet_frag_queue *q;
@ -237,4 +237,23 @@ struct inet_frag_queue *inet_frag_create(struct inet_frags *f, void *arg,
return inet_frag_intern(q, f, hash);
}
EXPORT_SYMBOL(inet_frag_create);
struct inet_frag_queue *inet_frag_find(struct inet_frags *f, void *key,
unsigned int hash)
{
struct inet_frag_queue *q;
struct hlist_node *n;
read_lock(&f->lock);
hlist_for_each_entry(q, n, &f->hash[hash], list) {
if (f->match(q, key)) {
atomic_inc(&q->refcnt);
read_unlock(&f->lock);
return q;
}
}
read_unlock(&f->lock);
return inet_frag_create(f, key, hash);
}
EXPORT_SYMBOL(inet_frag_find);

57
net/ipv4/ip_fragment.c
View file

@ -142,6 +142,19 @@ static int ip4_frag_equal(struct inet_frag_queue *q1,
qp1->user == qp2->user);
}
static int ip4_frag_match(struct inet_frag_queue *q, void *a)
{
struct ipq *qp;
struct ip4_create_arg *arg = a;
qp = container_of(q, struct ipq, q);
return (qp->id == arg->iph->id &&
qp->saddr == arg->iph->saddr &&
qp->daddr == arg->iph->daddr &&
qp->protocol == arg->iph->protocol &&
qp->user == arg->user);
}
/* Memory Tracking Functions. */
static __inline__ void frag_kfree_skb(struct sk_buff *skb, int *work)
{
@ -235,18 +248,20 @@ out:
ipq_put(qp);
}
/* Creation primitives. */
/* Add an entry to the 'ipq' queue for a newly received IP datagram. */
static struct ipq *ip_frag_create(struct iphdr *iph, u32 user, unsigned int h)
/* Find the correct entry in the "incomplete datagrams" queue for
* this IP datagram, and create new one, if nothing is found.
*/
static inline struct ipq *ip_find(struct iphdr *iph, u32 user)
{
struct inet_frag_queue *q;
struct ip4_create_arg arg;
unsigned int hash;
arg.iph = iph;
arg.user = user;
hash = ipqhashfn(iph->id, iph->saddr, iph->daddr, iph->protocol);
q = inet_frag_create(&ip4_frags, &arg, h);
q = inet_frag_find(&ip4_frags, &arg, hash);
if (q == NULL)
goto out_nomem;
@ -257,37 +272,6 @@ out_nomem:
return NULL;
}
/* Find the correct entry in the "incomplete datagrams" queue for
* this IP datagram, and create new one, if nothing is found.
*/
static inline struct ipq *ip_find(struct iphdr *iph, u32 user)
{
__be16 id = iph->id;
__be32 saddr = iph->saddr;
__be32 daddr = iph->daddr;
__u8 protocol = iph->protocol;
unsigned int hash;
struct ipq *qp;
struct hlist_node *n;
read_lock(&ip4_frags.lock);
hash = ipqhashfn(id, saddr, daddr, protocol);
hlist_for_each_entry(qp, n, &ip4_frags.hash[hash], q.list) {
if (qp->id == id &&
qp->saddr == saddr &&
qp->daddr == daddr &&
qp->protocol == protocol &&
qp->user == user) {
atomic_inc(&qp->q.refcnt);
read_unlock(&ip4_frags.lock);
return qp;
}
}
read_unlock(&ip4_frags.lock);
return ip_frag_create(iph, user, hash);
}
/* Is the fragment too far ahead to be part of ipq? */
static inline int ip_frag_too_far(struct ipq *qp)
{
@ -648,6 +632,7 @@ void __init ipfrag_init(void)
ip4_frags.skb_free = NULL;
ip4_frags.qsize = sizeof(struct ipq);
ip4_frags.equal = ip4_frag_equal;
ip4_frags.match = ip4_frag_match;
ip4_frags.frag_expire = ip_expire;
inet_frags_init(&ip4_frags);
}