drivers/staging/android/sync_debug.c

   1 /*
   2  * drivers/base/sync.c
   3  *
   4  * Copyright (C) 2012 Google, Inc.
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/debugfs.h>
  18 #include "sync.h"
  19
  20 #ifdef CONFIG_DEBUG_FS
  21
  22 static struct dentry *dbgfs;
  23
  24 static LIST_HEAD(sync_timeline_list_head);
  25 static DEFINE_SPINLOCK(sync_timeline_list_lock);
  26 static LIST_HEAD(sync_file_list_head);
  27 static DEFINE_SPINLOCK(sync_file_list_lock);
  28
  29 void sync_timeline_debug_add(struct sync_timeline *obj)
  30 {
  31         unsigned long flags;
  32
  33         spin_lock_irqsave(&sync_timeline_list_lock, flags);
  34         list_add_tail(&obj->sync_timeline_list, &sync_timeline_list_head);
  35         spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
  36 }
  37
  38 void sync_timeline_debug_remove(struct sync_timeline *obj)
  39 {
  40         unsigned long flags;
  41
  42         spin_lock_irqsave(&sync_timeline_list_lock, flags);
  43         list_del(&obj->sync_timeline_list);
  44         spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
  45 }
  46
  47 void sync_file_debug_add(struct sync_file *sync_file)
  48 {
  49         unsigned long flags;
  50
  51         spin_lock_irqsave(&sync_file_list_lock, flags);
  52         list_add_tail(&sync_file->sync_file_list, &sync_file_list_head);
  53         spin_unlock_irqrestore(&sync_file_list_lock, flags);
  54 }
  55
  56 void sync_file_debug_remove(struct sync_file *sync_file)
  57 {
  58         unsigned long flags;
  59
  60         spin_lock_irqsave(&sync_file_list_lock, flags);
  61         list_del(&sync_file->sync_file_list);
  62         spin_unlock_irqrestore(&sync_file_list_lock, flags);
  63 }
  64
  65 static const char *sync_status_str(int status)
  66 {
  67         if (status == 0)
  68                 return "signaled";
  69
  70         if (status > 0)
  71                 return "active";
  72
  73         return "error";
  74 }
  75
  76 static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show)
  77 {
  78         int status = 1;
  79         struct sync_timeline *parent = fence_parent(fence);
  80
  81         if (fence_is_signaled_locked(fence))
  82                 status = fence->status;
  83
  84         seq_printf(s, "  %s%sfence %s",
  85                    show ? parent->name : "",
  86                    show ? "_" : "",
  87                    sync_status_str(status));
  88
  89         if (status <= 0) {
  90                 struct timespec64 ts64 =
  91                         ktime_to_timespec64(fence->timestamp);
  92
  93                 seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec);
  94         }
  95
  96         if (fence->ops->timeline_value_str &&
  97                 fence->ops->fence_value_str) {
  98                 char value[64];
  99                 bool success;
 100
 101                 fence->ops->fence_value_str(fence, value, sizeof(value));
 102                 success = strlen(value);
 103
 104                 if (success) {
 105                         seq_printf(s, ": %s", value);
 106
 107                         fence->ops->timeline_value_str(fence, value,
 108                                                        sizeof(value));
 109
 110                         if (strlen(value))
 111                                 seq_printf(s, " / %s", value);
 112                 }
 113         }
 114
 115         seq_puts(s, "\n");
 116 }
 117
 118 static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj)
 119 {
 120         struct list_head *pos;
 121         unsigned long flags;
 122
 123         seq_printf(s, "%s %s: %d\n", obj->name, obj->drv_name, obj->value);
 124
 125         spin_lock_irqsave(&obj->child_list_lock, flags);
 126         list_for_each(pos, &obj->child_list_head) {
 127                 struct sync_pt *pt =
 128                         container_of(pos, struct sync_pt, child_list);
 129                 sync_print_fence(s, &pt->base, false);
 130         }
 131         spin_unlock_irqrestore(&obj->child_list_lock, flags);
 132 }
 133
 134 static void sync_print_sync_file(struct seq_file *s,
 135                                   struct sync_file *sync_file)
 136 {
 137         int i;
 138
 139         seq_printf(s, "[%p] %s: %s\n", sync_file, sync_file->name,
 140                    sync_status_str(atomic_read(&sync_file->status)));
 141
 142         for (i = 0; i < sync_file->num_fences; ++i)
 143                 sync_print_fence(s, sync_file->cbs[i].fence, true);
 144 }
 145
 146 static int sync_debugfs_show(struct seq_file *s, void *unused)
 147 {
 148         unsigned long flags;
 149         struct list_head *pos;
 150
 151         seq_puts(s, "objs:\n--------------\n");
 152
 153         spin_lock_irqsave(&sync_timeline_list_lock, flags);
 154         list_for_each(pos, &sync_timeline_list_head) {
 155                 struct sync_timeline *obj =
 156                         container_of(pos, struct sync_timeline,
 157                                      sync_timeline_list);
 158
 159                 sync_print_obj(s, obj);
 160                 seq_puts(s, "\n");
 161         }
 162         spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
 163
 164         seq_puts(s, "fences:\n--------------\n");
 165
 166         spin_lock_irqsave(&sync_file_list_lock, flags);
 167         list_for_each(pos, &sync_file_list_head) {
 168                 struct sync_file *sync_file =
 169                         container_of(pos, struct sync_file, sync_file_list);
 170
 171                 sync_print_sync_file(s, sync_file);
 172                 seq_puts(s, "\n");
 173         }
 174         spin_unlock_irqrestore(&sync_file_list_lock, flags);
 175         return 0;
 176 }
 177
 178 static int sync_info_debugfs_open(struct inode *inode, struct file *file)
 179 {
 180         return single_open(file, sync_debugfs_show, inode->i_private);
 181 }
 182
 183 static const struct file_operations sync_info_debugfs_fops = {
 184         .open           = sync_info_debugfs_open,
 185         .read           = seq_read,
 186         .llseek         = seq_lseek,
 187         .release        = single_release,
 188 };
 189
 190 static __init int sync_debugfs_init(void)
 191 {
 192         dbgfs = debugfs_create_dir("sync", NULL);
 193
 194         debugfs_create_file("info", 0444, dbgfs, NULL, &sync_info_debugfs_fops);
 195
 196         debugfs_create_file("sw_sync", 0644, dbgfs, NULL,
 197                             &sw_sync_debugfs_fops);
 198
 199         return 0;
 200 }
 201 late_initcall(sync_debugfs_init);
 202
 203 #define DUMP_CHUNK 256
 204 static char sync_dump_buf[64 * 1024];
 205 void sync_dump(void)
 206 {
 207         struct seq_file s = {
 208                 .buf = sync_dump_buf,
 209                 .size = sizeof(sync_dump_buf) - 1,
 210         };
 211         int i;
 212
 213         sync_debugfs_show(&s, NULL);
 214
 215         for (i = 0; i < s.count; i += DUMP_CHUNK) {
 216                 if ((s.count - i) > DUMP_CHUNK) {
 217                         char c = s.buf[i + DUMP_CHUNK];
 218
 219                         s.buf[i + DUMP_CHUNK] = 0;
 220                         pr_cont("%s", s.buf + i);
 221                         s.buf[i + DUMP_CHUNK] = c;
 222                 } else {
 223                         s.buf[s.count] = 0;
 224                         pr_cont("%s", s.buf + i);
 225                 }
 226         }
 227 }
 228
 229 #endif