mirror of https://github.com/torvalds/linux.git
Merge branch 'ref_tracker-add-ability-to-register-a-debugfs-file-for-a-ref_tracker_dir'
Jeff Layton says: ==================== ref_tracker: add ability to register a debugfs file for a ref_tracker_dir For those just joining in, this series adds a new top-level "ref_tracker" debugfs directory, and has each ref_tracker_dir register a file in there as part of its initialization. It also adds the ability to register a symlink with a more human-usable name that points to the file, and does some general cleanup of how the ref_tracker object names are handled. v14: https://lore.kernel.org/20250610-reftrack-dbgfs-v14-0-efb532861428@kernel.org v13: https://lore.kernel.org/20250603-reftrack-dbgfs-v13-0-7b2a425019d8@kernel.org v12: https://lore.kernel.org/20250529-reftrack-dbgfs-v12-0-11b93c0c0b6e@kernel.org v11: https://lore.kernel.org/20250528-reftrack-dbgfs-v11-0-94ae0b165841@kernel.org v10: https://lore.kernel.org/20250527-reftrack-dbgfs-v10-0-dc55f7705691@kernel.org v9: https://lore.kernel.org/20250509-reftrack-dbgfs-v9-0-8ab888a4524d@kernel.org v8: https://lore.kernel.org/20250507-reftrack-dbgfs-v8-0-607717d3bb98@kernel.org v7: https://lore.kernel.org/20250505-reftrack-dbgfs-v7-0-f78c5d97bcca@kernel.org v6: https://lore.kernel.org/20250430-reftrack-dbgfs-v6-0-867c29aff03a@kernel.org v5: https://lore.kernel.org/20250428-reftrack-dbgfs-v5-0-1cbbdf2038bd@kernel.org v4: https://lore.kernel.org/20250418-reftrack-dbgfs-v4-0-5ca5c7899544@kernel.org v3: https://lore.kernel.org/20250417-reftrack-dbgfs-v3-0-c3159428c8fb@kernel.org v2: https://lore.kernel.org/20250415-reftrack-dbgfs-v2-0-b18c4abd122f@kernel.org v1: https://lore.kernel.org/20250414-reftrack-dbgfs-v1-0-f03585832203@kernel.org ==================== Link: https://patch.msgid.link/20250618-reftrack-dbgfs-v15-0-24fc37ead144@kernel.org Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski
commit
77f08133bc
|
|
@ -1920,7 +1920,7 @@ drm_dp_tunnel_mgr_create(struct drm_device *dev, int max_group_count)
|
|||
}
|
||||
|
||||
#ifdef CONFIG_DRM_DISPLAY_DP_TUNNEL_STATE_DEBUG
|
||||
ref_tracker_dir_init(&mgr->ref_tracker, 16, "dptun");
|
||||
ref_tracker_dir_init(&mgr->ref_tracker, 16, "drm_dptun");
|
||||
#endif
|
||||
|
||||
for (i = 0; i < max_group_count; i++) {
|
||||
|
|
|
|||
|
|
@ -59,7 +59,9 @@ static struct drm_i915_private *rpm_to_i915(struct intel_runtime_pm *rpm)
|
|||
|
||||
static void init_intel_runtime_pm_wakeref(struct intel_runtime_pm *rpm)
|
||||
{
|
||||
ref_tracker_dir_init(&rpm->debug, INTEL_REFTRACK_DEAD_COUNT, dev_name(rpm->kdev));
|
||||
if (!rpm->debug.class)
|
||||
ref_tracker_dir_init(&rpm->debug, INTEL_REFTRACK_DEAD_COUNT,
|
||||
"intel_runtime_pm");
|
||||
}
|
||||
|
||||
static intel_wakeref_t
|
||||
|
|
|
|||
|
|
@ -114,7 +114,8 @@ void __intel_wakeref_init(struct intel_wakeref *wf,
|
|||
"wakeref.work", &key->work, 0);
|
||||
|
||||
#if IS_ENABLED(CONFIG_DRM_I915_DEBUG_WAKEREF)
|
||||
ref_tracker_dir_init(&wf->debug, INTEL_REFTRACK_DEAD_COUNT, name);
|
||||
if (!wf->debug.class)
|
||||
ref_tracker_dir_init(&wf->debug, INTEL_REFTRACK_DEAD_COUNT, "intel_wakeref");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,6 +6,8 @@
|
|||
#include <linux/spinlock.h>
|
||||
#include <linux/stackdepot.h>
|
||||
|
||||
#define __ostream_printf __printf(2, 3)
|
||||
|
||||
struct ref_tracker;
|
||||
|
||||
struct ref_tracker_dir {
|
||||
|
|
@ -17,15 +19,45 @@ struct ref_tracker_dir {
|
|||
bool dead;
|
||||
struct list_head list; /* List of active trackers */
|
||||
struct list_head quarantine; /* List of dead trackers */
|
||||
char name[32];
|
||||
const char *class; /* object classname */
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifdef CONFIG_REF_TRACKER
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
|
||||
void ref_tracker_dir_debugfs(struct ref_tracker_dir *dir);
|
||||
void ref_tracker_dir_symlink(struct ref_tracker_dir *dir, const char *fmt, ...);
|
||||
|
||||
#else /* CONFIG_DEBUG_FS */
|
||||
|
||||
static inline void ref_tracker_dir_debugfs(struct ref_tracker_dir *dir)
|
||||
{
|
||||
}
|
||||
|
||||
static inline __ostream_printf
|
||||
void ref_tracker_dir_symlink(struct ref_tracker_dir *dir, const char *fmt, ...)
|
||||
{
|
||||
}
|
||||
|
||||
#endif /* CONFIG_DEBUG_FS */
|
||||
|
||||
/**
|
||||
* ref_tracker_dir_init - initialize a ref_tracker dir
|
||||
* @dir: ref_tracker_dir to be initialized
|
||||
* @quarantine_count: max number of entries to be tracked
|
||||
* @class: pointer to static string that describes object type
|
||||
*
|
||||
* Initialize a ref_tracker_dir. If debugfs is configured, then a file
|
||||
* will also be created for it under the top-level ref_tracker debugfs
|
||||
* directory.
|
||||
*
|
||||
* Note that @class must point to a static string.
|
||||
*/
|
||||
static inline void ref_tracker_dir_init(struct ref_tracker_dir *dir,
|
||||
unsigned int quarantine_count,
|
||||
const char *name)
|
||||
const char *class)
|
||||
{
|
||||
INIT_LIST_HEAD(&dir->list);
|
||||
INIT_LIST_HEAD(&dir->quarantine);
|
||||
|
|
@ -34,7 +66,8 @@ static inline void ref_tracker_dir_init(struct ref_tracker_dir *dir,
|
|||
dir->dead = false;
|
||||
refcount_set(&dir->untracked, 1);
|
||||
refcount_set(&dir->no_tracker, 1);
|
||||
strscpy(dir->name, name, sizeof(dir->name));
|
||||
dir->class = class;
|
||||
ref_tracker_dir_debugfs(dir);
|
||||
stack_depot_init();
|
||||
}
|
||||
|
||||
|
|
@ -58,7 +91,16 @@ int ref_tracker_free(struct ref_tracker_dir *dir,
|
|||
|
||||
static inline void ref_tracker_dir_init(struct ref_tracker_dir *dir,
|
||||
unsigned int quarantine_count,
|
||||
const char *name)
|
||||
const char *class)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void ref_tracker_dir_debugfs(struct ref_tracker_dir *dir)
|
||||
{
|
||||
}
|
||||
|
||||
static inline __ostream_printf
|
||||
void ref_tracker_dir_symlink(struct ref_tracker_dir *dir, const char *fmt, ...)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include <linux/slab.h>
|
||||
#include <linux/stacktrace.h>
|
||||
#include <linux/stackdepot.h>
|
||||
#include <linux/seq_file.h>
|
||||
|
||||
#define REF_TRACKER_STACK_ENTRIES 16
|
||||
#define STACK_BUF_SIZE 1024
|
||||
|
|
@ -28,6 +29,45 @@ struct ref_tracker_dir_stats {
|
|||
} stacks[];
|
||||
};
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
#include <linux/xarray.h>
|
||||
|
||||
/*
|
||||
* ref_tracker_dir_init() is usually called in allocation-safe contexts, but
|
||||
* the same is not true of ref_tracker_dir_exit() which can be called from
|
||||
* anywhere an object is freed. Removing debugfs dentries is a blocking
|
||||
* operation, so we defer that work to the debugfs_reap_worker.
|
||||
*
|
||||
* Each dentry is tracked in the appropriate xarray. When
|
||||
* ref_tracker_dir_exit() is called, its entries in the xarrays are marked and
|
||||
* the workqueue job is scheduled. The worker then runs and deletes any marked
|
||||
* dentries asynchronously.
|
||||
*/
|
||||
static struct xarray debugfs_dentries;
|
||||
static struct xarray debugfs_symlinks;
|
||||
static struct work_struct debugfs_reap_worker;
|
||||
|
||||
#define REF_TRACKER_DIR_DEAD XA_MARK_0
|
||||
static inline void ref_tracker_debugfs_mark(struct ref_tracker_dir *dir)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
xa_lock_irqsave(&debugfs_dentries, flags);
|
||||
__xa_set_mark(&debugfs_dentries, (unsigned long)dir, REF_TRACKER_DIR_DEAD);
|
||||
xa_unlock_irqrestore(&debugfs_dentries, flags);
|
||||
|
||||
xa_lock_irqsave(&debugfs_symlinks, flags);
|
||||
__xa_set_mark(&debugfs_symlinks, (unsigned long)dir, REF_TRACKER_DIR_DEAD);
|
||||
xa_unlock_irqrestore(&debugfs_symlinks, flags);
|
||||
|
||||
schedule_work(&debugfs_reap_worker);
|
||||
}
|
||||
#else
|
||||
static inline void ref_tracker_debugfs_mark(struct ref_tracker_dir *dir)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct ref_tracker_dir_stats *
|
||||
ref_tracker_get_stats(struct ref_tracker_dir *dir, unsigned int limit)
|
||||
{
|
||||
|
|
@ -63,21 +103,39 @@ ref_tracker_get_stats(struct ref_tracker_dir *dir, unsigned int limit)
|
|||
}
|
||||
|
||||
struct ostream {
|
||||
void __ostream_printf (*func)(struct ostream *stream, char *fmt, ...);
|
||||
char *prefix;
|
||||
char *buf;
|
||||
struct seq_file *seq;
|
||||
int size, used;
|
||||
};
|
||||
|
||||
static void __ostream_printf pr_ostream_log(struct ostream *stream, char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
vprintk(fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
static void __ostream_printf pr_ostream_buf(struct ostream *stream, char *fmt, ...)
|
||||
{
|
||||
int ret, len = stream->size - stream->used;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
ret = vsnprintf(stream->buf + stream->used, len, fmt, args);
|
||||
va_end(args);
|
||||
if (ret > 0)
|
||||
stream->used += min(ret, len);
|
||||
}
|
||||
|
||||
#define pr_ostream(stream, fmt, args...) \
|
||||
({ \
|
||||
struct ostream *_s = (stream); \
|
||||
\
|
||||
if (!_s->buf) { \
|
||||
pr_err(fmt, ##args); \
|
||||
} else { \
|
||||
int ret, len = _s->size - _s->used; \
|
||||
ret = snprintf(_s->buf + _s->used, len, pr_fmt(fmt), ##args); \
|
||||
_s->used += min(ret, len); \
|
||||
} \
|
||||
_s->func(_s, fmt, ##args); \
|
||||
})
|
||||
|
||||
static void
|
||||
|
|
@ -96,8 +154,8 @@ __ref_tracker_dir_pr_ostream(struct ref_tracker_dir *dir,
|
|||
|
||||
stats = ref_tracker_get_stats(dir, display_limit);
|
||||
if (IS_ERR(stats)) {
|
||||
pr_ostream(s, "%s@%pK: couldn't get stats, error %pe\n",
|
||||
dir->name, dir, stats);
|
||||
pr_ostream(s, "%s%s@%p: couldn't get stats, error %pe\n",
|
||||
s->prefix, dir->class, dir, stats);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -107,14 +165,15 @@ __ref_tracker_dir_pr_ostream(struct ref_tracker_dir *dir,
|
|||
stack = stats->stacks[i].stack_handle;
|
||||
if (sbuf && !stack_depot_snprint(stack, sbuf, STACK_BUF_SIZE, 4))
|
||||
sbuf[0] = 0;
|
||||
pr_ostream(s, "%s@%pK has %d/%d users at\n%s\n", dir->name, dir,
|
||||
stats->stacks[i].count, stats->total, sbuf);
|
||||
pr_ostream(s, "%s%s@%p has %d/%d users at\n%s\n", s->prefix,
|
||||
dir->class, dir, stats->stacks[i].count,
|
||||
stats->total, sbuf);
|
||||
skipped -= stats->stacks[i].count;
|
||||
}
|
||||
|
||||
if (skipped)
|
||||
pr_ostream(s, "%s@%pK skipped reports about %d/%d users.\n",
|
||||
dir->name, dir, skipped, stats->total);
|
||||
pr_ostream(s, "%s%s@%p skipped reports about %d/%d users.\n",
|
||||
s->prefix, dir->class, dir, skipped, stats->total);
|
||||
|
||||
kfree(sbuf);
|
||||
|
||||
|
|
@ -124,7 +183,8 @@ __ref_tracker_dir_pr_ostream(struct ref_tracker_dir *dir,
|
|||
void ref_tracker_dir_print_locked(struct ref_tracker_dir *dir,
|
||||
unsigned int display_limit)
|
||||
{
|
||||
struct ostream os = {};
|
||||
struct ostream os = { .func = pr_ostream_log,
|
||||
.prefix = "ref_tracker: " };
|
||||
|
||||
__ref_tracker_dir_pr_ostream(dir, display_limit, &os);
|
||||
}
|
||||
|
|
@ -143,7 +203,10 @@ EXPORT_SYMBOL(ref_tracker_dir_print);
|
|||
|
||||
int ref_tracker_dir_snprint(struct ref_tracker_dir *dir, char *buf, size_t size)
|
||||
{
|
||||
struct ostream os = { .buf = buf, .size = size };
|
||||
struct ostream os = { .func = pr_ostream_buf,
|
||||
.prefix = "ref_tracker: ",
|
||||
.buf = buf,
|
||||
.size = size };
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&dir->lock, flags);
|
||||
|
|
@ -161,6 +224,11 @@ void ref_tracker_dir_exit(struct ref_tracker_dir *dir)
|
|||
bool leak = false;
|
||||
|
||||
dir->dead = true;
|
||||
/*
|
||||
* The xarray entries must be marked before the dir->lock is taken to
|
||||
* protect simultaneous debugfs readers.
|
||||
*/
|
||||
ref_tracker_debugfs_mark(dir);
|
||||
spin_lock_irqsave(&dir->lock, flags);
|
||||
list_for_each_entry_safe(tracker, n, &dir->quarantine, head) {
|
||||
list_del(&tracker->head);
|
||||
|
|
@ -273,3 +341,188 @@ int ref_tracker_free(struct ref_tracker_dir *dir,
|
|||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ref_tracker_free);
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
#include <linux/debugfs.h>
|
||||
|
||||
static struct dentry *ref_tracker_debug_dir = (struct dentry *)-ENOENT;
|
||||
|
||||
static void __ostream_printf pr_ostream_seq(struct ostream *stream, char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
seq_vprintf(stream->seq, fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
static int ref_tracker_dir_seq_print(struct ref_tracker_dir *dir, struct seq_file *seq)
|
||||
{
|
||||
struct ostream os = { .func = pr_ostream_seq,
|
||||
.prefix = "",
|
||||
.seq = seq };
|
||||
|
||||
__ref_tracker_dir_pr_ostream(dir, 16, &os);
|
||||
|
||||
return os.used;
|
||||
}
|
||||
|
||||
static int ref_tracker_debugfs_show(struct seq_file *f, void *v)
|
||||
{
|
||||
struct ref_tracker_dir *dir = f->private;
|
||||
unsigned long index = (unsigned long)dir;
|
||||
unsigned long flags;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* "dir" may not exist at this point if ref_tracker_dir_exit() has
|
||||
* already been called. Take care not to dereference it until its
|
||||
* legitimacy is established.
|
||||
*
|
||||
* The xa_lock is necessary to ensure that "dir" doesn't disappear
|
||||
* before its lock can be taken. If it's in the hash and not marked
|
||||
* dead, then it's safe to take dir->lock which prevents
|
||||
* ref_tracker_dir_exit() from completing. Once the dir->lock is
|
||||
* acquired, the xa_lock can be released. All of this must be IRQ-safe.
|
||||
*/
|
||||
xa_lock_irqsave(&debugfs_dentries, flags);
|
||||
if (!xa_load(&debugfs_dentries, index) ||
|
||||
xa_get_mark(&debugfs_dentries, index, REF_TRACKER_DIR_DEAD)) {
|
||||
xa_unlock_irqrestore(&debugfs_dentries, flags);
|
||||
return -ENODATA;
|
||||
}
|
||||
|
||||
spin_lock(&dir->lock);
|
||||
xa_unlock(&debugfs_dentries);
|
||||
ret = ref_tracker_dir_seq_print(dir, f);
|
||||
spin_unlock_irqrestore(&dir->lock, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ref_tracker_debugfs_open(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct ref_tracker_dir *dir = inode->i_private;
|
||||
|
||||
return single_open(filp, ref_tracker_debugfs_show, dir);
|
||||
}
|
||||
|
||||
static const struct file_operations ref_tracker_debugfs_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = ref_tracker_debugfs_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release,
|
||||
};
|
||||
|
||||
/**
|
||||
* ref_tracker_dir_debugfs - create debugfs file for ref_tracker_dir
|
||||
* @dir: ref_tracker_dir to be associated with debugfs file
|
||||
*
|
||||
* In most cases, a debugfs file will be created automatically for every
|
||||
* ref_tracker_dir. If the object was created before debugfs is brought up
|
||||
* then that may fail. In those cases, it is safe to call this at a later
|
||||
* time to create the file.
|
||||
*/
|
||||
void ref_tracker_dir_debugfs(struct ref_tracker_dir *dir)
|
||||
{
|
||||
char name[NAME_MAX + 1];
|
||||
struct dentry *dentry;
|
||||
int ret;
|
||||
|
||||
/* No-op if already created */
|
||||
dentry = xa_load(&debugfs_dentries, (unsigned long)dir);
|
||||
if (dentry && !xa_is_err(dentry))
|
||||
return;
|
||||
|
||||
ret = snprintf(name, sizeof(name), "%s@%px", dir->class, dir);
|
||||
name[sizeof(name) - 1] = '\0';
|
||||
|
||||
if (ret < sizeof(name)) {
|
||||
dentry = debugfs_create_file(name, S_IFREG | 0400,
|
||||
ref_tracker_debug_dir, dir,
|
||||
&ref_tracker_debugfs_fops);
|
||||
if (!IS_ERR(dentry)) {
|
||||
void *old;
|
||||
|
||||
old = xa_store_irq(&debugfs_dentries, (unsigned long)dir,
|
||||
dentry, GFP_KERNEL);
|
||||
|
||||
if (xa_is_err(old))
|
||||
debugfs_remove(dentry);
|
||||
else
|
||||
WARN_ON_ONCE(old);
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(ref_tracker_dir_debugfs);
|
||||
|
||||
void __ostream_printf ref_tracker_dir_symlink(struct ref_tracker_dir *dir, const char *fmt, ...)
|
||||
{
|
||||
char name[NAME_MAX + 1];
|
||||
struct dentry *symlink, *dentry;
|
||||
va_list args;
|
||||
int ret;
|
||||
|
||||
symlink = xa_load(&debugfs_symlinks, (unsigned long)dir);
|
||||
dentry = xa_load(&debugfs_dentries, (unsigned long)dir);
|
||||
|
||||
/* Already created?*/
|
||||
if (symlink && !xa_is_err(symlink))
|
||||
return;
|
||||
|
||||
if (!dentry || xa_is_err(dentry))
|
||||
return;
|
||||
|
||||
va_start(args, fmt);
|
||||
ret = vsnprintf(name, sizeof(name), fmt, args);
|
||||
va_end(args);
|
||||
name[sizeof(name) - 1] = '\0';
|
||||
|
||||
if (ret < sizeof(name)) {
|
||||
symlink = debugfs_create_symlink(name, ref_tracker_debug_dir,
|
||||
dentry->d_name.name);
|
||||
if (!IS_ERR(symlink)) {
|
||||
void *old;
|
||||
|
||||
old = xa_store_irq(&debugfs_symlinks, (unsigned long)dir,
|
||||
symlink, GFP_KERNEL);
|
||||
if (xa_is_err(old))
|
||||
debugfs_remove(symlink);
|
||||
else
|
||||
WARN_ON_ONCE(old);
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(ref_tracker_dir_symlink);
|
||||
|
||||
static void debugfs_reap_work(struct work_struct *work)
|
||||
{
|
||||
struct dentry *dentry;
|
||||
unsigned long index;
|
||||
bool reaped;
|
||||
|
||||
do {
|
||||
reaped = false;
|
||||
xa_for_each_marked(&debugfs_symlinks, index, dentry, REF_TRACKER_DIR_DEAD) {
|
||||
xa_erase_irq(&debugfs_symlinks, index);
|
||||
debugfs_remove(dentry);
|
||||
reaped = true;
|
||||
}
|
||||
xa_for_each_marked(&debugfs_dentries, index, dentry, REF_TRACKER_DIR_DEAD) {
|
||||
xa_erase_irq(&debugfs_dentries, index);
|
||||
debugfs_remove(dentry);
|
||||
reaped = true;
|
||||
}
|
||||
} while (reaped);
|
||||
}
|
||||
|
||||
static int __init ref_tracker_debugfs_init(void)
|
||||
{
|
||||
INIT_WORK(&debugfs_reap_worker, debugfs_reap_work);
|
||||
xa_init_flags(&debugfs_dentries, XA_FLAGS_LOCK_IRQ);
|
||||
xa_init_flags(&debugfs_symlinks, XA_FLAGS_LOCK_IRQ);
|
||||
ref_tracker_debug_dir = debugfs_create_dir("ref_tracker", NULL);
|
||||
return 0;
|
||||
}
|
||||
late_initcall(ref_tracker_debugfs_init);
|
||||
#endif /* CONFIG_DEBUG_FS */
|
||||
|
|
|
|||
|
|
@ -11756,7 +11756,7 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
|
|||
|
||||
dev->priv_len = sizeof_priv;
|
||||
|
||||
ref_tracker_dir_init(&dev->refcnt_tracker, 128, name);
|
||||
ref_tracker_dir_init(&dev->refcnt_tracker, 128, "netdev");
|
||||
#ifdef CONFIG_PCPU_DEV_REFCNT
|
||||
dev->pcpu_refcnt = alloc_percpu(int);
|
||||
if (!dev->pcpu_refcnt)
|
||||
|
|
|
|||
|
|
@ -403,8 +403,8 @@ static __net_init void preinit_net(struct net *net, struct user_namespace *user_
|
|||
{
|
||||
refcount_set(&net->passive, 1);
|
||||
refcount_set(&net->ns.count, 1);
|
||||
ref_tracker_dir_init(&net->refcnt_tracker, 128, "net refcnt");
|
||||
ref_tracker_dir_init(&net->notrefcnt_tracker, 128, "net notrefcnt");
|
||||
ref_tracker_dir_init(&net->refcnt_tracker, 128, "net_refcnt");
|
||||
ref_tracker_dir_init(&net->notrefcnt_tracker, 128, "net_notrefcnt");
|
||||
|
||||
get_random_bytes(&net->hash_mix, sizeof(u32));
|
||||
net->dev_base_seq = 1;
|
||||
|
|
@ -791,12 +791,40 @@ struct net *get_net_ns_by_pid(pid_t pid)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(get_net_ns_by_pid);
|
||||
|
||||
#ifdef CONFIG_NET_NS_REFCNT_TRACKER
|
||||
static void net_ns_net_debugfs(struct net *net)
|
||||
{
|
||||
ref_tracker_dir_symlink(&net->refcnt_tracker, "netns-%llx-%u-refcnt",
|
||||
net->net_cookie, net->ns.inum);
|
||||
ref_tracker_dir_symlink(&net->notrefcnt_tracker, "netns-%llx-%u-notrefcnt",
|
||||
net->net_cookie, net->ns.inum);
|
||||
}
|
||||
|
||||
static int __init init_net_debugfs(void)
|
||||
{
|
||||
ref_tracker_dir_debugfs(&init_net.refcnt_tracker);
|
||||
ref_tracker_dir_debugfs(&init_net.notrefcnt_tracker);
|
||||
net_ns_net_debugfs(&init_net);
|
||||
return 0;
|
||||
}
|
||||
late_initcall(init_net_debugfs);
|
||||
#else
|
||||
static void net_ns_net_debugfs(struct net *net)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
static __net_init int net_ns_net_init(struct net *net)
|
||||
{
|
||||
int ret;
|
||||
|
||||
#ifdef CONFIG_NET_NS
|
||||
net->ns.ops = &netns_operations;
|
||||
#endif
|
||||
return ns_alloc_inum(&net->ns);
|
||||
ret = ns_alloc_inum(&net->ns);
|
||||
if (!ret)
|
||||
net_ns_net_debugfs(net);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static __net_exit void net_ns_net_exit(struct net *net)
|
||||
|
|
|
|||
Loading…
Reference in New Issue