Merge branch 'ref_tracker-add-ability-to-register-a-debugfs-file-for-a-ref_tracker_dir' (77f08133) · Commits · git / linux-net

drivers/gpu/drm/display/drm_dp_tunnel.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -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++) {

drivers/gpu/drm/i915/intel_runtime_pm.c

+3 −1

Original line number	Diff line number	Diff line
		@@ -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

drivers/gpu/drm/i915/intel_wakeref.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -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
		}

include/linux/ref_tracker.h

+46 −4

Original line number	Diff line number	Diff line
		@@ -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, ...)
		{
		}

lib/ref_tracker.c

+268 −15

Original line number	Diff line number	Diff line
		@@ -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 */