mirror of https://github.com/proski/madwifi
727 lines
20 KiB
C
727 lines
20 KiB
C
/*-
|
|
* Copyright (c) 2007 Michael Taylor, Apprion
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $Id: ieee80211_linux.c 2829 2007-11-05 20:43:50Z mtaylor $
|
|
*/
|
|
|
|
#ifndef EXPORT_SYMTAB
|
|
#define EXPORT_SYMTAB
|
|
#endif
|
|
|
|
/*
|
|
* IEEE 802.11 support (Linux-specific code)
|
|
*/
|
|
#if !defined(AUTOCONF_INCLUDED) && !defined(CONFIG_LOCALVERSION)
|
|
#include <linux/config.h>
|
|
#endif
|
|
#include <linux/version.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kmod.h>
|
|
#include <linux/init.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/if_vlan.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <net/iw_handler.h>
|
|
#include <linux/wireless.h>
|
|
#include <linux/if_arp.h> /* XXX for ARPHRD_* */
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "if_media.h"
|
|
#include "if_ethersubr.h"
|
|
|
|
#include <net80211/ieee80211_var.h>
|
|
#include <net80211/ieee80211_monitor.h>
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
|
|
#include <linux/device.h>
|
|
#endif
|
|
|
|
#undef alloc_skb
|
|
#undef dev_alloc_skb
|
|
#undef dev_kfree_skb
|
|
#undef dev_kfree_skb_any
|
|
#undef dev_kfree_skb_irq
|
|
#undef dev_queue_xmit
|
|
#undef kfree_skb
|
|
#undef kfree_skb_fast
|
|
#undef netif_rx
|
|
#undef pskb_copy
|
|
#undef skb_clone
|
|
#undef skb_copy
|
|
#undef skb_copy_expand
|
|
#undef skb_get
|
|
#undef skb_realloc_headroom
|
|
#undef skb_share_check
|
|
#undef skb_unshare
|
|
#undef vlan_hwaccel_rx
|
|
|
|
static atomic_t skb_total_counter = ATOMIC_INIT(0);
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
static atomic_t skb_refs_counter = ATOMIC_INIT(0);
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* Debug Helpers
|
|
******************************************************************************/
|
|
|
|
static void skb_print_message(
|
|
int show_counter,
|
|
const struct sk_buff *skb,
|
|
const char *func, int line,
|
|
const char *message,
|
|
...)
|
|
{
|
|
va_list args;
|
|
char skb_count[32] = { '\0' };
|
|
char expanded_message[256] = { '\0' };
|
|
if (show_counter) {
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
snprintf(skb_count,
|
|
sizeof(skb_count),
|
|
"[#SKB=%05d #REF=%05d] ",
|
|
atomic_read(&skb_total_counter),
|
|
atomic_read(&skb_refs_counter));
|
|
#else
|
|
snprintf(skb_count,
|
|
sizeof(skb_count),
|
|
"[#SKB=%05d] ",
|
|
atomic_read(&skb_total_counter));
|
|
#endif
|
|
|
|
}
|
|
va_start(args, message);
|
|
vsnprintf(expanded_message, sizeof(expanded_message), message, args);
|
|
printk(KERN_DEBUG "%s: %s%s:%d %s\n",
|
|
((skb != NULL) ? DEV_NAME(skb->dev) : "none"),
|
|
skb_count,
|
|
func, line,
|
|
expanded_message);
|
|
va_end(args);
|
|
}
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
|
|
static void
|
|
print_skb_refchange_message(
|
|
const struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line);
|
|
static void
|
|
print_skb_trackchange_message(
|
|
const struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line,
|
|
char *message);
|
|
|
|
/* Called automatically when an SKB reaches zero users,
|
|
* reporting any leaked node references. */
|
|
#ifdef IEEE80211_DEBUG_REFCNT_SKBDEST
|
|
static void skb_destructor(struct sk_buff *skb);
|
|
#endif
|
|
static void get_skb_description(char *dst, int dst_size, const char *label,
|
|
const struct sk_buff *skb, int users_adjustment);
|
|
|
|
static struct sk_buff *
|
|
clean_clone_or_copy(struct sk_buff *skb);
|
|
|
|
static struct sk_buff *
|
|
track_skb(struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line);
|
|
|
|
static struct sk_buff *
|
|
untrack_skb(struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line);
|
|
|
|
#define UNREF_USE_KFREE_SKB 0
|
|
#define UNREF_USE_DEV_KFREE_SKB_ANY 1
|
|
#define UNREF_USE_DEV_KFREE_SKB 2
|
|
#define UNREF_USE_DEV_KFREE_SKB_IRQ 3
|
|
|
|
/* Assumes SKB is not yet freed at the time of the call and shows the new users
|
|
* count as (users - 1). */
|
|
static void unref_skb(struct sk_buff *skb, int type,
|
|
const char *func, int line);
|
|
|
|
/* Assumes SKB reference counter has already been updated and reports count as
|
|
* atomic_read(&skb->users). */
|
|
static struct sk_buff *
|
|
ref_skb(struct sk_buff *skb,
|
|
const char *func, int line);
|
|
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT_SKBDEST
|
|
/* Destructor for reporting node reference leaks */
|
|
static void skb_destructor(struct sk_buff *skb) {
|
|
/* Report any node reference leaks - caused by kernel net device queue
|
|
* dropping buffer, rather than passing it to the driver. */
|
|
if (SKB_NI(skb) != NULL) {
|
|
printk(KERN_ERR "%s:%d - ERROR: non-NULL node pointer in %p, %p<" MAC_FMT ">! "
|
|
"Leak Detected!\n",
|
|
__func__, __LINE__,
|
|
skb, SKB_NI(skb), MAC_ADDR(SKB_NI(skb)->ni_macaddr));
|
|
dump_stack();
|
|
}
|
|
if (SKB_CB(skb)->next_destructor != NULL) {
|
|
SKB_CB(skb)->next_destructor(skb);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(skb_destructor);
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT_SKBDEST */
|
|
|
|
static void get_skb_description(char *dst, int dst_size, const char *label, const struct sk_buff *skb, int users_adjustment) {
|
|
dst[0] = '\0';
|
|
if (NULL != skb) {
|
|
int adj_users = atomic_read(&skb->users) + users_adjustment;
|
|
if (SKB_NI(skb) != NULL) {
|
|
snprintf(dst, dst_size,
|
|
" [%s%s%p,users=%d,node=%p<" MAC_FMT ">,aid=%d%s%s]",
|
|
label,
|
|
(label != NULL ? ": " : ""),
|
|
skb,
|
|
adj_users,
|
|
SKB_NI(skb),
|
|
MAC_ADDR(SKB_NI(skb)->ni_macaddr),
|
|
SKB_NI(skb)->ni_associd,
|
|
((adj_users < 0) ? " ** CORRUPTED **" : ""),
|
|
((adj_users == 0) ? " ** RELEASED **" : "")
|
|
);
|
|
}
|
|
else {
|
|
snprintf(dst, dst_size,
|
|
" [%s%s%p,users=%d,node=NULL,aid=N/A%s%s]",
|
|
label,
|
|
(label != NULL ? ": " : ""),
|
|
skb,
|
|
adj_users,
|
|
((adj_users < 0) ? " ** CORRUPTED **" : ""),
|
|
((adj_users == 0) ? " ** RELEASED **" : "")
|
|
);
|
|
}
|
|
dst[dst_size-1] = '\0';
|
|
}
|
|
}
|
|
|
|
static void print_skb_refchange_message(
|
|
const struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line)
|
|
{
|
|
char skb_desc[128] = { '\0' };
|
|
if (0 == (ath_debug_global & GLOBAL_DEBUG_SKB_REF))
|
|
return;
|
|
get_skb_description(skb_desc, sizeof(skb_desc),
|
|
"skb", skb, users_adjustment);
|
|
skb_print_message(0 /* no global count */, skb,
|
|
func, line,
|
|
skb_desc);
|
|
}
|
|
|
|
static void print_skb_trackchange_message(
|
|
const struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line,
|
|
char *message)
|
|
{
|
|
char skb_desc[128] = { '\0' };
|
|
if (0 == (ath_debug_global & GLOBAL_DEBUG_SKB))
|
|
return;
|
|
get_skb_description(skb_desc, sizeof(skb_desc),
|
|
"skb", skb, users_adjustment);
|
|
skb_print_message(1 /* show global count */, skb,
|
|
func, line,
|
|
"%s%s", skb_desc, message);
|
|
}
|
|
|
|
static struct sk_buff *
|
|
clean_clone_or_copy(struct sk_buff *skb) {
|
|
if (skb != NULL)
|
|
M_FLAG_CLR(skb, M_SKB_TRACKED);
|
|
return skb;
|
|
}
|
|
|
|
static struct sk_buff *
|
|
track_skb(struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line)
|
|
{
|
|
if (NULL == skb) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: NULL skb received. Skipping.");
|
|
return NULL;
|
|
}
|
|
if (M_FLAG_GET(skb, M_SKB_TRACKED)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Already tracked skb received. Skipping.");
|
|
dump_stack();
|
|
return skb;
|
|
}
|
|
if (skb_shared(skb)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Shared skb received. References leaked??");
|
|
dump_stack();
|
|
}
|
|
atomic_inc(&skb_total_counter);
|
|
atomic_inc(&skb_refs_counter);
|
|
M_FLAG_SET(skb, M_SKB_TRACKED);
|
|
print_skb_trackchange_message(skb, users_adjustment,
|
|
func, line,
|
|
" is now ** TRACKED **");
|
|
#ifdef IEEE80211_DEBUG_REFCNT_SKBDEST
|
|
/* Install our debug destructor, chaining to the original... */
|
|
if (skb->destructor != skb_destructor) {
|
|
SKB_CB(skb)->next_destructor = skb->destructor;
|
|
skb->destructor = skb_destructor;
|
|
}
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT_SKBDEST */
|
|
return skb;
|
|
}
|
|
|
|
static struct sk_buff *
|
|
untrack_skb(struct sk_buff *skb, int users_adjustment,
|
|
const char *func, int line)
|
|
{
|
|
if (NULL == skb) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: NULL skb received. No changes made.");
|
|
return NULL;
|
|
}
|
|
if (!M_FLAG_GET(skb, M_SKB_TRACKED)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Untracked skb received. No changes made.");
|
|
return skb;
|
|
}
|
|
if (skb_shared(skb)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Shared skb received. References leaked??");
|
|
}
|
|
atomic_dec(&skb_total_counter);
|
|
atomic_dec(&skb_refs_counter);
|
|
M_FLAG_CLR(skb, M_SKB_TRACKED);
|
|
#ifdef IEEE80211_DEBUG_REFCNT_SKBDEST
|
|
/* Uninstall our debug destructor, restoring any original... */
|
|
if (skb->destructor == skb_destructor) {
|
|
skb->destructor = SKB_CB(skb)->next_destructor;
|
|
SKB_CB(skb)->next_destructor = NULL;
|
|
}
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT_SKBDEST */
|
|
print_skb_trackchange_message(skb, users_adjustment,
|
|
func, line,
|
|
" is now ** UNTRACKED **");
|
|
return skb;
|
|
}
|
|
|
|
#define UNREF_USE_KFREE_SKB 0
|
|
#define UNREF_USE_DEV_KFREE_SKB_ANY 1
|
|
#define UNREF_USE_DEV_KFREE_SKB 2
|
|
#define UNREF_USE_DEV_KFREE_SKB_IRQ 3
|
|
|
|
/* Assumes SKB is not yet freed at the time of the call and shows the new users
|
|
* count as (users - 1). */
|
|
static void
|
|
unref_skb(struct sk_buff *skb, int type,
|
|
const char *func, int line)
|
|
{
|
|
if (NULL == skb) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: NULL skb received.");
|
|
dump_stack();
|
|
return;
|
|
}
|
|
if (!M_FLAG_GET(skb, M_SKB_TRACKED)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Untracked skb received. Probable duplicate free error!");
|
|
dump_stack();
|
|
return;
|
|
}
|
|
/* If free is unacceptable for current user count, report the error. */
|
|
if (atomic_read(&skb->users) < 1) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: free an skb with %d users",
|
|
atomic_read(&skb->users));
|
|
dump_stack();
|
|
return;
|
|
}
|
|
|
|
if (skb_shared(skb)) {
|
|
atomic_dec(&skb_refs_counter);
|
|
print_skb_refchange_message(skb, -1, func, line);
|
|
}
|
|
else {
|
|
if (SKB_NI(skb) != NULL) {
|
|
printk(KERN_ERR "%s:%d - ERROR: non-NULL node pointer in %p, %p<" MAC_FMT ">! "
|
|
"Driver Leak Detected!\n",
|
|
__func__, __LINE__,
|
|
skb, SKB_NI(skb), MAC_ADDR(SKB_NI(skb)->ni_macaddr));
|
|
dump_stack();
|
|
/* Allow the leak and let programmer fix it, but do not
|
|
* report it again in the destructor. */
|
|
SKB_NI(skb) = NULL;
|
|
}
|
|
untrack_skb(skb, -1, func, line);
|
|
}
|
|
|
|
if ((in_irq() || irqs_disabled()) &&
|
|
(type == UNREF_USE_KFREE_SKB ||
|
|
type == UNREF_USE_DEV_KFREE_SKB)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: free an skb in interrupt context using a non-"
|
|
"safe form of skb free function.");
|
|
type = UNREF_USE_DEV_KFREE_SKB_ANY;
|
|
dump_stack();
|
|
}
|
|
|
|
switch (type) {
|
|
case UNREF_USE_DEV_KFREE_SKB_ANY:
|
|
dev_kfree_skb_any(skb);
|
|
break;
|
|
case UNREF_USE_DEV_KFREE_SKB_IRQ:
|
|
dev_kfree_skb_irq(skb);
|
|
break;
|
|
case UNREF_USE_DEV_KFREE_SKB:
|
|
/* NOTE: dev_kfree_skb is a macro pointing to kfree_skb, so
|
|
* fallthrough... */
|
|
case UNREF_USE_KFREE_SKB:
|
|
/* fallthrough */
|
|
default:
|
|
kfree_skb(skb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Assumes SKB reference counter has already been updated and reports count as
|
|
* atomic_read(&skb->users). */
|
|
static struct sk_buff *
|
|
ref_skb(struct sk_buff *skb,
|
|
const char *func, int line)
|
|
{
|
|
if (NULL == skb) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: NULL skb received. No changes made.");
|
|
dump_stack();
|
|
return NULL;
|
|
}
|
|
if (!M_FLAG_GET(skb, M_SKB_TRACKED)) {
|
|
skb_print_message(0 /* show_counter */,
|
|
skb, func, line,
|
|
"ERROR: Untracked skb received. Probable use after free! "
|
|
"No changes made.");
|
|
dump_stack();
|
|
return skb;
|
|
}
|
|
print_skb_refchange_message(skb, 0, func, line);
|
|
return skb;
|
|
}
|
|
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT */
|
|
|
|
/*******************************************************************************
|
|
* Public API
|
|
******************************************************************************/
|
|
|
|
/* ieee80211_dev_kfree_skb will release one reference from SKB.
|
|
* If SKB refcount is going to zero:
|
|
* - Free the node reference and set it to null.
|
|
* - Break the linked list, clearing next skb's prev pointer if possible. */
|
|
void ieee80211_dev_kfree_skb(struct sk_buff **pskb)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
/* Do not fail on null, as we are going to use this in cleanup code. */
|
|
if (!pskb || !(skb = *pskb))
|
|
return;
|
|
|
|
/* Release the SKB references, for fragments of chain that are
|
|
* unshared... starting at skb passed in. */
|
|
if (skb->prev == NULL) {
|
|
if (skb->next != NULL)
|
|
skb->next->prev = NULL;
|
|
skb->next = NULL;
|
|
}
|
|
|
|
if (SKB_NI(skb) != NULL)
|
|
ieee80211_unref_node(&SKB_NI(skb));
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
unref_skb(skb, UNREF_USE_DEV_KFREE_SKB_ANY,
|
|
__func__, __LINE__);
|
|
#else
|
|
dev_kfree_skb_any(skb);
|
|
#endif
|
|
|
|
*pskb = NULL;
|
|
}
|
|
|
|
/* ieee80211_dev_kfree_skb_list will invoke ieee80211_dev_kfree_skb on each node in
|
|
* a list of skbs, starting with the first. */
|
|
void
|
|
ieee80211_dev_kfree_skb_list(struct sk_buff **pskb)
|
|
{
|
|
struct sk_buff *skb, *tskb;
|
|
|
|
/* Do not fail on null, as we are going to use this in cleanup code */
|
|
if (!pskb || !(skb = *pskb))
|
|
return;
|
|
|
|
while (skb) {
|
|
tskb = skb->next;
|
|
|
|
ieee80211_dev_kfree_skb(&skb);
|
|
skb = tskb;
|
|
}
|
|
|
|
*pskb = NULL;
|
|
}
|
|
|
|
struct sk_buff *
|
|
ieee80211_dev_alloc_skb(int size)
|
|
{
|
|
struct sk_buff *skb = dev_alloc_skb(size);
|
|
if (skb == NULL) {
|
|
skb_print_message(
|
|
0 /* show_counter */,
|
|
NULL /* skb */,
|
|
__func__, __LINE__,
|
|
"sk_buff allocation of size %u failed",
|
|
size);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
return track_skb(skb, 0, __func__, __LINE__);
|
|
#else
|
|
return skb;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ieee80211_skb_track(struct sk_buff *skb) {
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
track_skb(skb, 0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
#else
|
|
/* Just a dumb counter, in no-debug builds */
|
|
atomic_inc(&skb_total_counter);
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT */
|
|
}
|
|
|
|
void
|
|
ieee80211_skb_untrack(struct sk_buff *skb) {
|
|
/* Just a dumb counter, in no-debug builds */
|
|
atomic_dec(&skb_total_counter);
|
|
}
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
int
|
|
ieee80211_skb_counter(void) {
|
|
return atomic_read(&skb_total_counter);
|
|
}
|
|
|
|
int
|
|
ieee80211_skb_references(void) {
|
|
return atomic_read(&skb_refs_counter);
|
|
}
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT */
|
|
|
|
/*******************************************************************************
|
|
* skbuff leak/refcount debugging Replacement Functions
|
|
* PUT last in order to avoid conflicts with use of original functions in
|
|
* inline functions above this point.
|
|
******************************************************************************/
|
|
|
|
#ifdef IEEE80211_DEBUG_REFCNT
|
|
|
|
#if IEEE80211_VLAN_TAG_USED
|
|
int vlan_hwaccel_rx_debug(struct sk_buff *skb,
|
|
struct vlan_group *grp, unsigned short vlan_tag,
|
|
const char *func, int line) {
|
|
return vlan_hwaccel_rx(
|
|
untrack_skb(skb, 0, __func__, __LINE__),
|
|
grp, vlan_tag);
|
|
}
|
|
#endif
|
|
|
|
int netif_rx_debug(struct sk_buff *skb, const char *func, int line) {
|
|
return netif_rx(untrack_skb(skb, 0, __func__, __LINE__));
|
|
}
|
|
|
|
struct sk_buff *alloc_skb_debug(unsigned int length, gfp_t gfp_mask,
|
|
const char *func, int line) {
|
|
return track_skb(alloc_skb(length, gfp_mask),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
struct sk_buff *dev_alloc_skb_debug(unsigned int length,
|
|
const char *func, int line)
|
|
{
|
|
return track_skb(dev_alloc_skb(length),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
|
|
|
|
struct sk_buff *skb_clone_debug(struct sk_buff *skb, gfp_t pri,
|
|
const char *func, int line)
|
|
{
|
|
return track_skb(
|
|
clean_clone_or_copy(skb_clone(skb, pri)),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
struct sk_buff *skb_copy_debug(struct sk_buff *skb, gfp_t pri,
|
|
const char *func, int line)
|
|
{
|
|
return track_skb(
|
|
clean_clone_or_copy(skb_copy(skb, pri)), 0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
struct sk_buff *skb_get_debug(struct sk_buff *skb,
|
|
const char *func, int line)
|
|
{
|
|
return ref_skb(skb_get(skb),
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
struct sk_buff *skb_realloc_headroom_debug(struct sk_buff *skb, unsigned int headroom,
|
|
const char *func, int line)
|
|
{
|
|
/* skb_realloc_headroom ALWAYS returns a copy or a clone, refcount of
|
|
* new one is always zero and refcount of original is not touched. */
|
|
return track_skb(
|
|
clean_clone_or_copy(
|
|
skb_realloc_headroom(skb, headroom)),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
struct sk_buff *pskb_copy_debug(struct sk_buff *skb, gfp_t pri,
|
|
const char *func, int line)
|
|
{
|
|
return track_skb(
|
|
clean_clone_or_copy(pskb_copy(skb, pri)),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
int dev_queue_xmit_debug(struct sk_buff *skb,
|
|
const char *func, int line)
|
|
{
|
|
return dev_queue_xmit(untrack_skb(skb, 0, __func__, __LINE__));
|
|
}
|
|
|
|
struct sk_buff *skb_share_check_debug(struct sk_buff *skb, gfp_t pri,
|
|
const char *func, int line)
|
|
{
|
|
might_sleep_if(pri & __GFP_WAIT);
|
|
if (skb_shared(skb)) {
|
|
struct sk_buff *nskb = track_skb(
|
|
clean_clone_or_copy(skb_clone(skb, pri)),
|
|
0,
|
|
__func__, __LINE__);
|
|
unref_skb(skb, UNREF_USE_DEV_KFREE_SKB_ANY,
|
|
__func__, __LINE__);
|
|
skb = nskb;
|
|
}
|
|
return skb;
|
|
}
|
|
|
|
void kfree_skb_fast_debug(struct sk_buff *skb,
|
|
const char *func, int line)
|
|
{
|
|
/* NOT so fast... */
|
|
unref_skb(skb, UNREF_USE_DEV_KFREE_SKB_ANY, func, line);
|
|
}
|
|
|
|
struct sk_buff *skb_unshare_debug(struct sk_buff *skb, gfp_t pri,
|
|
const char *func, int line)
|
|
{
|
|
might_sleep_if(pri & __GFP_WAIT);
|
|
if (skb_cloned(skb)) {
|
|
struct sk_buff *nskb = track_skb(
|
|
clean_clone_or_copy(skb_copy(skb, pri)), 0,
|
|
__func__, __LINE__);
|
|
unref_skb(skb, UNREF_USE_DEV_KFREE_SKB_ANY,
|
|
__func__, __LINE__);
|
|
skb = nskb;
|
|
}
|
|
return skb;
|
|
}
|
|
|
|
struct sk_buff *skb_copy_expand_debug(const struct sk_buff *skb, int newheadroom,
|
|
int newtailroom, gfp_t gfp_mask,
|
|
const char *func, int line)
|
|
{
|
|
return track_skb(
|
|
clean_clone_or_copy(
|
|
skb_copy_expand(skb, newheadroom, newtailroom, gfp_mask)),
|
|
0 /* users_adjustment */,
|
|
__func__, __LINE__);
|
|
}
|
|
|
|
#if IEEE80211_VLAN_TAG_USED
|
|
EXPORT_SYMBOL(vlan_hwaccel_rx_debug);
|
|
#endif
|
|
EXPORT_SYMBOL(netif_rx_debug);
|
|
EXPORT_SYMBOL(alloc_skb_debug);
|
|
EXPORT_SYMBOL(dev_alloc_skb_debug);
|
|
EXPORT_SYMBOL(skb_clone_debug);
|
|
EXPORT_SYMBOL(skb_copy_debug);
|
|
EXPORT_SYMBOL(skb_get_debug);
|
|
EXPORT_SYMBOL(skb_realloc_headroom_debug);
|
|
EXPORT_SYMBOL(pskb_copy_debug);
|
|
EXPORT_SYMBOL(dev_queue_xmit_debug);
|
|
EXPORT_SYMBOL(skb_share_check_debug);
|
|
EXPORT_SYMBOL(kfree_skb_fast_debug);
|
|
EXPORT_SYMBOL(skb_unshare_debug);
|
|
EXPORT_SYMBOL(skb_copy_expand_debug);
|
|
|
|
EXPORT_SYMBOL(ieee80211_skb_counter);
|
|
EXPORT_SYMBOL(ieee80211_skb_references);
|
|
#endif /* #ifdef IEEE80211_DEBUG_REFCNT */
|
|
|
|
EXPORT_SYMBOL(ieee80211_dev_alloc_skb);
|
|
EXPORT_SYMBOL(ieee80211_skb_untrack);
|
|
EXPORT_SYMBOL(ieee80211_dev_kfree_skb_list);
|
|
EXPORT_SYMBOL(ieee80211_dev_kfree_skb);
|
|
EXPORT_SYMBOL(ieee80211_skb_track);
|
|
|