1 /* ar-skbuff.c: socket buffer destruction handling 2 * 3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/net.h> 16 #include <linux/skbuff.h> 17 #include <net/sock.h> 18 #include <net/af_rxrpc.h> 19 #include "ar-internal.h" 20 21 #define select_skb_count(op) (op >= rxrpc_skb_tx_cleaned ? &rxrpc_n_tx_skbs : &rxrpc_n_rx_skbs) 22 23 /* 24 * Note the allocation or reception of a socket buffer. 25 */ 26 void rxrpc_new_skb(struct sk_buff *skb, enum rxrpc_skb_trace op) 27 { 28 const void *here = __builtin_return_address(0); 29 int n = atomic_inc_return(select_skb_count(op)); 30 trace_rxrpc_skb(skb, op, atomic_read(&skb->users), n, here); 31 } 32 33 /* 34 * Note the re-emergence of a socket buffer from a queue or buffer. 35 */ 36 void rxrpc_see_skb(struct sk_buff *skb, enum rxrpc_skb_trace op) 37 { 38 const void *here = __builtin_return_address(0); 39 if (skb) { 40 int n = atomic_read(select_skb_count(op)); 41 trace_rxrpc_skb(skb, op, atomic_read(&skb->users), n, here); 42 } 43 } 44 45 /* 46 * Note the addition of a ref on a socket buffer. 47 */ 48 void rxrpc_get_skb(struct sk_buff *skb, enum rxrpc_skb_trace op) 49 { 50 const void *here = __builtin_return_address(0); 51 int n = atomic_inc_return(select_skb_count(op)); 52 trace_rxrpc_skb(skb, op, atomic_read(&skb->users), n, here); 53 skb_get(skb); 54 } 55 56 /* 57 * Note the destruction of a socket buffer. 58 */ 59 void rxrpc_free_skb(struct sk_buff *skb, enum rxrpc_skb_trace op) 60 { 61 const void *here = __builtin_return_address(0); 62 if (skb) { 63 int n; 64 CHECK_SLAB_OKAY(&skb->users); 65 n = atomic_dec_return(select_skb_count(op)); 66 trace_rxrpc_skb(skb, op, atomic_read(&skb->users), n, here); 67 kfree_skb(skb); 68 } 69 } 70 71 /* 72 * Note the injected loss of a socket buffer. 73 */ 74 void rxrpc_lose_skb(struct sk_buff *skb, enum rxrpc_skb_trace op) 75 { 76 const void *here = __builtin_return_address(0); 77 if (skb) { 78 int n; 79 CHECK_SLAB_OKAY(&skb->users); 80 n = atomic_dec_return(select_skb_count(op)); 81 trace_rxrpc_skb(skb, op, atomic_read(&skb->users), n, here); 82 kfree_skb(skb); 83 } 84 } 85 86 /* 87 * Clear a queue of socket buffers. 88 */ 89 void rxrpc_purge_queue(struct sk_buff_head *list) 90 { 91 const void *here = __builtin_return_address(0); 92 struct sk_buff *skb; 93 while ((skb = skb_dequeue((list))) != NULL) { 94 int n = atomic_dec_return(select_skb_count(rxrpc_skb_rx_purged)); 95 trace_rxrpc_skb(skb, rxrpc_skb_rx_purged, 96 atomic_read(&skb->users), n, here); 97 kfree_skb(skb); 98 } 99 } 100