1// SPDX-License-Identifier: GPL-2.0-or-later
 2/* Socket buffer accounting
 3 *
 4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 5 * Written by David Howells (dhowells@redhat.com)
 6 */
 7
 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 9
10#include <linux/module.h>
11#include <linux/net.h>
12#include <linux/skbuff.h>
13#include <net/sock.h>
14#include <net/af_rxrpc.h>
15#include "ar-internal.h"
16
17#define select_skb_count(skb) (&rxrpc_n_rx_skbs)
 
18
19/*
20 * Note the allocation or reception of a socket buffer.
21 */
22void rxrpc_new_skb(struct sk_buff *skb, enum rxrpc_skb_trace why)
23{
 
24	int n = atomic_inc_return(select_skb_count(skb));
25	trace_rxrpc_skb(skb, refcount_read(&skb->users), n, why);
 
26}
27
28/*
29 * Note the re-emergence of a socket buffer from a queue or buffer.
30 */
31void rxrpc_see_skb(struct sk_buff *skb, enum rxrpc_skb_trace why)
32{
 
33	if (skb) {
34		int n = atomic_read(select_skb_count(skb));
35		trace_rxrpc_skb(skb, refcount_read(&skb->users), n, why);
 
36	}
37}
38
39/*
40 * Note the addition of a ref on a socket buffer.
41 */
42void rxrpc_get_skb(struct sk_buff *skb, enum rxrpc_skb_trace why)
43{
 
44	int n = atomic_inc_return(select_skb_count(skb));
45	trace_rxrpc_skb(skb, refcount_read(&skb->users), n, why);
 
46	skb_get(skb);
47}
48
49/*
50 * Note the dropping of a ref on a socket buffer by the core.
51 */
52void rxrpc_eaten_skb(struct sk_buff *skb, enum rxrpc_skb_trace why)
53{
 
54	int n = atomic_inc_return(&rxrpc_n_rx_skbs);
55	trace_rxrpc_skb(skb, 0, n, why);
56}
57
58/*
59 * Note the destruction of a socket buffer.
60 */
61void rxrpc_free_skb(struct sk_buff *skb, enum rxrpc_skb_trace why)
62{
 
63	if (skb) {
64		int n = atomic_dec_return(select_skb_count(skb));
65		trace_rxrpc_skb(skb, refcount_read(&skb->users), n, why);
 
 
 
66		kfree_skb(skb);
67	}
68}
69
70/*
71 * Clear a queue of socket buffers.
72 */
73void rxrpc_purge_queue(struct sk_buff_head *list)
74{
 
75	struct sk_buff *skb;
76
77	while ((skb = skb_dequeue((list))) != NULL) {
78		int n = atomic_dec_return(select_skb_count(skb));
79		trace_rxrpc_skb(skb, refcount_read(&skb->users), n,
80				rxrpc_skb_put_purge);
 
81		kfree_skb(skb);
82	}
83}

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