lib/ref_tracker.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 #include <linux/export.h>
   3 #include <linux/ref_tracker.h>
   4 #include <linux/slab.h>
   5 #include <linux/stacktrace.h>
   6 #include <linux/stackdepot.h>
   7
   8 #define REF_TRACKER_STACK_ENTRIES 16
   9
  10 struct ref_tracker {
  11         struct list_head        head;   /* anchor into dir->list or dir->quarantine */
  12         bool                    dead;
  13         depot_stack_handle_t    alloc_stack_handle;
  14         depot_stack_handle_t    free_stack_handle;
  15 };
  16
  17 void ref_tracker_dir_exit(struct ref_tracker_dir *dir)
  18 {
  19         struct ref_tracker *tracker, *n;
  20         unsigned long flags;
  21         bool leak = false;
  22
  23         dir->dead = true;
  24         spin_lock_irqsave(&dir->lock, flags);
  25         list_for_each_entry_safe(tracker, n, &dir->quarantine, head) {
  26                 list_del(&tracker->head);
  27                 kfree(tracker);
  28                 dir->quarantine_avail++;
  29         }
  30         list_for_each_entry_safe(tracker, n, &dir->list, head) {
  31                 pr_err("leaked reference.\n");
  32                 if (tracker->alloc_stack_handle)
  33                         stack_depot_print(tracker->alloc_stack_handle);
  34                 leak = true;
  35                 list_del(&tracker->head);
  36                 kfree(tracker);
  37         }
  38         spin_unlock_irqrestore(&dir->lock, flags);
  39         WARN_ON_ONCE(leak);
  40         WARN_ON_ONCE(refcount_read(&dir->untracked) != 1);
  41         WARN_ON_ONCE(refcount_read(&dir->no_tracker) != 1);
  42 }
  43 EXPORT_SYMBOL(ref_tracker_dir_exit);
  44
  45 void ref_tracker_dir_print(struct ref_tracker_dir *dir,
  46                            unsigned int display_limit)
  47 {
  48         struct ref_tracker *tracker;
  49         unsigned long flags;
  50         unsigned int i = 0;
  51
  52         spin_lock_irqsave(&dir->lock, flags);
  53         list_for_each_entry(tracker, &dir->list, head) {
  54                 if (i < display_limit) {
  55                         pr_err("leaked reference.\n");
  56                         if (tracker->alloc_stack_handle)
  57                                 stack_depot_print(tracker->alloc_stack_handle);
  58                         i++;
  59                 } else {
  60                         break;
  61                 }
  62         }
  63         spin_unlock_irqrestore(&dir->lock, flags);
  64 }
  65 EXPORT_SYMBOL(ref_tracker_dir_print);
  66
  67 int ref_tracker_alloc(struct ref_tracker_dir *dir,
  68                       struct ref_tracker **trackerp,
  69                       gfp_t gfp)
  70 {
  71         unsigned long entries[REF_TRACKER_STACK_ENTRIES];
  72         struct ref_tracker *tracker;
  73         unsigned int nr_entries;
  74         gfp_t gfp_mask = gfp;
  75         unsigned long flags;
  76
  77         WARN_ON_ONCE(dir->dead);
  78
  79         if (!trackerp) {
  80                 refcount_inc(&dir->no_tracker);
  81                 return 0;
  82         }
  83         if (gfp & __GFP_DIRECT_RECLAIM)
  84                 gfp_mask |= __GFP_NOFAIL;
  85         *trackerp = tracker = kzalloc(sizeof(*tracker), gfp_mask);
  86         if (unlikely(!tracker)) {
  87                 pr_err_once("memory allocation failure, unreliable refcount tracker.\n");
  88                 refcount_inc(&dir->untracked);
  89                 return -ENOMEM;
  90         }
  91         nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 1);
  92         tracker->alloc_stack_handle = stack_depot_save(entries, nr_entries, gfp);
  93
  94         spin_lock_irqsave(&dir->lock, flags);
  95         list_add(&tracker->head, &dir->list);
  96         spin_unlock_irqrestore(&dir->lock, flags);
  97         return 0;
  98 }
  99 EXPORT_SYMBOL_GPL(ref_tracker_alloc);
 100
 101 int ref_tracker_free(struct ref_tracker_dir *dir,
 102                      struct ref_tracker **trackerp)
 103 {
 104         unsigned long entries[REF_TRACKER_STACK_ENTRIES];
 105         depot_stack_handle_t stack_handle;
 106         struct ref_tracker *tracker;
 107         unsigned int nr_entries;
 108         unsigned long flags;
 109
 110         WARN_ON_ONCE(dir->dead);
 111
 112         if (!trackerp) {
 113                 refcount_dec(&dir->no_tracker);
 114                 return 0;
 115         }
 116         tracker = *trackerp;
 117         if (!tracker) {
 118                 refcount_dec(&dir->untracked);
 119                 return -EEXIST;
 120         }
 121         nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 1);
 122         stack_handle = stack_depot_save(entries, nr_entries, GFP_ATOMIC);
 123
 124         spin_lock_irqsave(&dir->lock, flags);
 125         if (tracker->dead) {
 126                 pr_err("reference already released.\n");
 127                 if (tracker->alloc_stack_handle) {
 128                         pr_err("allocated in:\n");
 129                         stack_depot_print(tracker->alloc_stack_handle);
 130                 }
 131                 if (tracker->free_stack_handle) {
 132                         pr_err("freed in:\n");
 133                         stack_depot_print(tracker->free_stack_handle);
 134                 }
 135                 spin_unlock_irqrestore(&dir->lock, flags);
 136                 WARN_ON_ONCE(1);
 137                 return -EINVAL;
 138         }
 139         tracker->dead = true;
 140
 141         tracker->free_stack_handle = stack_handle;
 142
 143         list_move_tail(&tracker->head, &dir->quarantine);
 144         if (!dir->quarantine_avail) {
 145                 tracker = list_first_entry(&dir->quarantine, struct ref_tracker, head);
 146                 list_del(&tracker->head);
 147         } else {
 148                 dir->quarantine_avail--;
 149                 tracker = NULL;
 150         }
 151         spin_unlock_irqrestore(&dir->lock, flags);
 152
 153         kfree(tracker);
 154         return 0;
 155 }
 156 EXPORT_SYMBOL_GPL(ref_tracker_free);