Commit 6ffe75eb authored by Eric Dumazet's avatar Eric Dumazet Committed by David S. Miller
Browse files

net: avoid two atomic operations in fast clones 



Commit ce1a4ea3 ("net: avoid one atomic operation in skb_clone()")
took the wrong way to save one atomic operation.

It is actually possible to avoid two atomic operations, if we
do not change skb->fclone values, and only rely on clone_ref
content to signal if the clone is available or not.

skb_clone() can simply use the fast clone if clone_ref is 1.

kfree_skbmem() can avoid the atomic_dec_and_test() if clone_ref is 1.

Note that because we usually free the clone before the original skb,
this particular attempt is only done for the original skb to have better
branch prediction.

SKB_FCLONE_FREE is removed.

Signed-off-by: default avatarEric Dumazet <edumazet@google.com>
Cc: Chris Mason <clm@fb.com>
Cc: Sabrina Dubroca <sd@queasysnail.net>
Cc: Vijay Subramanian <subramanian.vijay@gmail.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 395eea6c

include/linux/skbuff.h

+1 −2
Original line number Diff line number Diff line
@@ -344,7 +344,6 @@ enum { 
	SKB_FCLONE_UNAVAILABLE,	/* skb has no fclone (from head_cache) */

	SKB_FCLONE_ORIG,	/* orig skb (from fclone_cache) */

	SKB_FCLONE_CLONE,	/* companion fclone skb (from fclone_cache) */

	SKB_FCLONE_FREE,	/* this companion fclone skb is available */

};



enum {
@@ -818,7 +817,7 @@ static inline bool skb_fclone_busy(const struct sock *sk, 
	fclones = container_of(skb, struct sk_buff_fclones, skb1);



	return skb->fclone == SKB_FCLONE_ORIG &&

	       fclones->skb2.fclone == SKB_FCLONE_CLONE &&

	       atomic_read(&fclones->fclone_ref) > 1 &&

	       fclones->skb2.sk == sk;

}

net/core/skbuff.c

+18 −17
Original line number Diff line number Diff line
@@ -265,7 +265,7 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, 
		skb->fclone = SKB_FCLONE_ORIG;

		atomic_set(&fclones->fclone_ref, 1);



		fclones->skb2.fclone = SKB_FCLONE_FREE;

		fclones->skb2.fclone = SKB_FCLONE_CLONE;

		fclones->skb2.pfmemalloc = pfmemalloc;

	}

out:
@@ -541,26 +541,27 @@ static void kfree_skbmem(struct sk_buff *skb) 
	switch (skb->fclone) {

	case SKB_FCLONE_UNAVAILABLE:

		kmem_cache_free(skbuff_head_cache, skb);

		break;

		return;



	case SKB_FCLONE_ORIG:

		fclones = container_of(skb, struct sk_buff_fclones, skb1);

		if (atomic_dec_and_test(&fclones->fclone_ref))

			kmem_cache_free(skbuff_fclone_cache, fclones);

		break;



	case SKB_FCLONE_CLONE:

		fclones = container_of(skb, struct sk_buff_fclones, skb2);



		/* The clone portion is available for

		 * fast-cloning again.

		/* We usually free the clone (TX completion) before original skb

		 * This test would have no chance to be true for the clone,

		 * while here, branch prediction will be good.

		 */

		skb->fclone = SKB_FCLONE_FREE;

		if (atomic_read(&fclones->fclone_ref) == 1)

			goto fastpath;

		break;



		if (atomic_dec_and_test(&fclones->fclone_ref))

			kmem_cache_free(skbuff_fclone_cache, fclones);

	default: /* SKB_FCLONE_CLONE */

		fclones = container_of(skb, struct sk_buff_fclones, skb2);

		break;

	}

	if (!atomic_dec_and_test(&fclones->fclone_ref))

		return;

fastpath:

	kmem_cache_free(skbuff_fclone_cache, fclones);

}



static void skb_release_head_state(struct sk_buff *skb)
@@ -872,15 +873,15 @@ struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask) 
	struct sk_buff_fclones *fclones = container_of(skb,

						       struct sk_buff_fclones,

						       skb1);

	struct sk_buff *n = &fclones->skb2;

	struct sk_buff *n;



	if (skb_orphan_frags(skb, gfp_mask))

		return NULL;



	if (skb->fclone == SKB_FCLONE_ORIG &&

	    n->fclone == SKB_FCLONE_FREE) {

		n->fclone = SKB_FCLONE_CLONE;

		atomic_inc(&fclones->fclone_ref);

	    atomic_read(&fclones->fclone_ref) == 1) {

		n = &fclones->skb2;

		atomic_set(&fclones->fclone_ref, 2);

	} else {

		if (skb_pfmemalloc(skb))

			gfp_mask |= __GFP_MEMALLOC;

CRA Git | Maintained and supported by SUSTech CRA and CCSE