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
);