4 * Copyright (C) 2012 Google, Inc.
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.
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.
17 #include <linux/debugfs.h>
18 #include <linux/export.h>
19 #include <linux/file.h>
21 #include <linux/kernel.h>
22 #include <linux/poll.h>
23 #include <linux/sched.h>
24 #include <linux/seq_file.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <linux/anon_inodes.h>
28 #include <linux/time64.h>
29 #include <linux/sync_file.h>
30 #include <linux/types.h>
31 #include <linux/kconfig.h>
33 #include "uapi/sw_sync.h"
36 #ifdef CONFIG_DEBUG_FS
38 static struct dentry *dbgfs;
40 static LIST_HEAD(sync_timeline_list_head);
41 static DEFINE_SPINLOCK(sync_timeline_list_lock);
42 static LIST_HEAD(sync_file_list_head);
43 static DEFINE_SPINLOCK(sync_file_list_lock);
45 void sync_timeline_debug_add(struct sync_timeline *obj)
49 spin_lock_irqsave(&sync_timeline_list_lock, flags);
50 list_add_tail(&obj->sync_timeline_list, &sync_timeline_list_head);
51 spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
54 void sync_timeline_debug_remove(struct sync_timeline *obj)
58 spin_lock_irqsave(&sync_timeline_list_lock, flags);
59 list_del(&obj->sync_timeline_list);
60 spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
63 void sync_file_debug_add(struct sync_file *sync_file)
67 spin_lock_irqsave(&sync_file_list_lock, flags);
68 list_add_tail(&sync_file->sync_file_list, &sync_file_list_head);
69 spin_unlock_irqrestore(&sync_file_list_lock, flags);
72 void sync_file_debug_remove(struct sync_file *sync_file)
76 spin_lock_irqsave(&sync_file_list_lock, flags);
77 list_del(&sync_file->sync_file_list);
78 spin_unlock_irqrestore(&sync_file_list_lock, flags);
81 static const char *sync_status_str(int status)
92 static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show)
95 struct sync_timeline *parent = fence_parent(fence);
97 if (fence_is_signaled_locked(fence))
98 status = fence->status;
100 seq_printf(s, " %s%sfence %s",
101 show ? parent->name : "",
103 sync_status_str(status));
106 struct timespec64 ts64 =
107 ktime_to_timespec64(fence->timestamp);
109 seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec);
112 if ((!fence || fence->ops->timeline_value_str) &&
113 fence->ops->fence_value_str) {
117 fence->ops->fence_value_str(fence, value, sizeof(value));
118 success = strlen(value);
121 seq_printf(s, ": %s", value);
123 if (success && fence) {
124 fence->ops->timeline_value_str(fence, value,
128 seq_printf(s, " / %s", value);
135 static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj)
137 struct list_head *pos;
140 seq_printf(s, "%s %s: %d\n", obj->name, obj->drv_name, obj->value);
142 spin_lock_irqsave(&obj->child_list_lock, flags);
143 list_for_each(pos, &obj->child_list_head) {
144 struct fence *fence =
145 container_of(pos, struct fence, child_list);
146 sync_print_fence(s, fence, false);
148 spin_unlock_irqrestore(&obj->child_list_lock, flags);
151 static void sync_print_sync_file(struct seq_file *s,
152 struct sync_file *sync_file)
156 seq_printf(s, "[%p] %s: %s\n", sync_file, sync_file->name,
157 sync_status_str(atomic_read(&sync_file->status)));
159 for (i = 0; i < sync_file->num_fences; ++i)
160 sync_print_fence(s, sync_file->cbs[i].fence, true);
163 static int sync_debugfs_show(struct seq_file *s, void *unused)
166 struct list_head *pos;
168 seq_puts(s, "objs:\n--------------\n");
170 spin_lock_irqsave(&sync_timeline_list_lock, flags);
171 list_for_each(pos, &sync_timeline_list_head) {
172 struct sync_timeline *obj =
173 container_of(pos, struct sync_timeline,
176 sync_print_obj(s, obj);
179 spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
181 seq_puts(s, "fences:\n--------------\n");
183 spin_lock_irqsave(&sync_file_list_lock, flags);
184 list_for_each(pos, &sync_file_list_head) {
185 struct sync_file *sync_file =
186 container_of(pos, struct sync_file, sync_file_list);
188 sync_print_sync_file(s, sync_file);
191 spin_unlock_irqrestore(&sync_file_list_lock, flags);
195 static int sync_info_debugfs_open(struct inode *inode, struct file *file)
197 return single_open(file, sync_debugfs_show, inode->i_private);
200 static const struct file_operations sync_info_debugfs_fops = {
201 .open = sync_info_debugfs_open,
204 .release = single_release,
207 #if IS_ENABLED(CONFIG_SW_SYNC)
211 * improper use of this can result in deadlocking kernel drivers from userspace.
214 /* opening sw_sync create a new sync obj */
215 static int sw_sync_debugfs_open(struct inode *inode, struct file *file)
217 struct sync_timeline *obj;
218 char task_comm[TASK_COMM_LEN];
220 get_task_comm(task_comm, current);
222 obj = sync_timeline_create(sizeof(*obj), "sw_sync", task_comm);
226 file->private_data = obj;
231 static int sw_sync_debugfs_release(struct inode *inode, struct file *file)
233 struct sync_timeline *obj = file->private_data;
235 sync_timeline_destroy(obj);
239 static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
242 int fd = get_unused_fd_flags(O_CLOEXEC);
245 struct sync_file *sync_file;
246 struct sw_sync_create_fence_data data;
251 if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
256 fence = sync_pt_create(obj, sizeof(*fence), data.value);
262 sync_file = sync_file_create(fence);
270 if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
271 fput(sync_file->file);
276 fd_install(fd, sync_file->file);
285 static long sw_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
289 if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
292 sync_timeline_signal(obj, value);
297 static long sw_sync_ioctl(struct file *file, unsigned int cmd,
300 struct sync_timeline *obj = file->private_data;
303 case SW_SYNC_IOC_CREATE_FENCE:
304 return sw_sync_ioctl_create_fence(obj, arg);
306 case SW_SYNC_IOC_INC:
307 return sw_sync_ioctl_inc(obj, arg);
314 static const struct file_operations sw_sync_debugfs_fops = {
315 .open = sw_sync_debugfs_open,
316 .release = sw_sync_debugfs_release,
317 .unlocked_ioctl = sw_sync_ioctl,
318 .compat_ioctl = sw_sync_ioctl,
322 static __init int sync_debugfs_init(void)
324 dbgfs = debugfs_create_dir("sync", NULL);
326 debugfs_create_file("info", 0444, dbgfs, NULL, &sync_info_debugfs_fops);
328 #if IS_ENABLED(CONFIG_SW_SYNC)
329 debugfs_create_file("sw_sync", 0644, dbgfs, NULL,
330 &sw_sync_debugfs_fops);
335 late_initcall(sync_debugfs_init);
337 #define DUMP_CHUNK 256
338 static char sync_dump_buf[64 * 1024];
341 struct seq_file s = {
342 .buf = sync_dump_buf,
343 .size = sizeof(sync_dump_buf) - 1,
347 sync_debugfs_show(&s, NULL);
349 for (i = 0; i < s.count; i += DUMP_CHUNK) {
350 if ((s.count - i) > DUMP_CHUNK) {
351 char c = s.buf[i + DUMP_CHUNK];
353 s.buf[i + DUMP_CHUNK] = 0;
354 pr_cont("%s", s.buf + i);
355 s.buf[i + DUMP_CHUNK] = c;
358 pr_cont("%s", s.buf + i);