Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / arch / powerpc / platforms / cell / spufs / sputrace.c
1 /*
2  * Copyright (C) 2007 IBM Deutschland Entwicklung GmbH
3  *      Released under GPL v2.
4  *
5  * Partially based on net/ipv4/tcp_probe.c.
6  *
7  * Simple tracing facility for spu contexts.
8  */
9 #include <linux/sched.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/marker.h>
13 #include <linux/proc_fs.h>
14 #include <linux/wait.h>
15 #include <asm/atomic.h>
16 #include <asm/uaccess.h>
17 #include "spufs.h"
18
19 struct spu_probe {
20         const char *name;
21         const char *format;
22         marker_probe_func *probe_func;
23 };
24
25 struct sputrace {
26         ktime_t tstamp;
27         int owner_tid; /* owner */
28         int curr_tid;
29         const char *name;
30         int number;
31 };
32
33 static int bufsize __read_mostly = 16384;
34 MODULE_PARM_DESC(bufsize, "Log buffer size (number of records)");
35 module_param(bufsize, int, 0);
36
37
38 static DEFINE_SPINLOCK(sputrace_lock);
39 static DECLARE_WAIT_QUEUE_HEAD(sputrace_wait);
40 static ktime_t sputrace_start;
41 static unsigned long sputrace_head, sputrace_tail;
42 static struct sputrace *sputrace_log;
43 static int sputrace_logging;
44
45 static int sputrace_used(void)
46 {
47         return (sputrace_head - sputrace_tail) % bufsize;
48 }
49
50 static inline int sputrace_avail(void)
51 {
52         return bufsize - sputrace_used();
53 }
54
55 static int sputrace_sprint(char *tbuf, int n)
56 {
57         const struct sputrace *t = sputrace_log + sputrace_tail % bufsize;
58         struct timespec tv =
59                 ktime_to_timespec(ktime_sub(t->tstamp, sputrace_start));
60
61         return snprintf(tbuf, n,
62                 "[%lu.%09lu] %d: %s (ctxthread = %d, spu = %d)\n",
63                 (unsigned long) tv.tv_sec,
64                 (unsigned long) tv.tv_nsec,
65                 t->curr_tid,
66                 t->name,
67                 t->owner_tid,
68                 t->number);
69 }
70
71 static ssize_t sputrace_read(struct file *file, char __user *buf,
72                 size_t len, loff_t *ppos)
73 {
74         int error = 0, cnt = 0;
75
76         if (!buf || len < 0)
77                 return -EINVAL;
78
79         while (cnt < len) {
80                 char tbuf[128];
81                 int width;
82
83                 /* If we have data ready to return, don't block waiting
84                  * for more */
85                 if (cnt > 0 && sputrace_used() == 0)
86                         break;
87
88                 error = wait_event_interruptible(sputrace_wait,
89                                                  sputrace_used() > 0);
90                 if (error)
91                         break;
92
93                 spin_lock(&sputrace_lock);
94                 if (sputrace_head == sputrace_tail) {
95                         spin_unlock(&sputrace_lock);
96                         continue;
97                 }
98
99                 width = sputrace_sprint(tbuf, sizeof(tbuf));
100                 if (width < len)
101                         sputrace_tail = (sputrace_tail + 1) % bufsize;
102                 spin_unlock(&sputrace_lock);
103
104                 if (width >= len)
105                         break;
106
107                 error = copy_to_user(buf + cnt, tbuf, width);
108                 if (error)
109                         break;
110                 cnt += width;
111         }
112
113         return cnt == 0 ? error : cnt;
114 }
115
116 static int sputrace_open(struct inode *inode, struct file *file)
117 {
118         int rc;
119
120         spin_lock(&sputrace_lock);
121         if (sputrace_logging) {
122                 rc = -EBUSY;
123                 goto out;
124         }
125
126         sputrace_logging = 1;
127         sputrace_head = sputrace_tail = 0;
128         sputrace_start = ktime_get();
129         rc = 0;
130
131 out:
132         spin_unlock(&sputrace_lock);
133         return rc;
134 }
135
136 static int sputrace_release(struct inode *inode, struct file *file)
137 {
138         spin_lock(&sputrace_lock);
139         sputrace_logging = 0;
140         spin_unlock(&sputrace_lock);
141         return 0;
142 }
143
144 static const struct file_operations sputrace_fops = {
145         .owner   = THIS_MODULE,
146         .open    = sputrace_open,
147         .read    = sputrace_read,
148         .release = sputrace_release,
149 };
150
151 static void sputrace_log_item(const char *name, struct spu_context *ctx,
152                 struct spu *spu)
153 {
154         spin_lock(&sputrace_lock);
155
156         if (!sputrace_logging) {
157                 spin_unlock(&sputrace_lock);
158                 return;
159         }
160
161         if (sputrace_avail() > 1) {
162                 struct sputrace *t = sputrace_log + sputrace_head;
163
164                 t->tstamp = ktime_get();
165                 t->owner_tid = ctx->tid;
166                 t->name = name;
167                 t->curr_tid = current->pid;
168                 t->number = spu ? spu->number : -1;
169
170                 sputrace_head = (sputrace_head + 1) % bufsize;
171         } else {
172                 printk(KERN_WARNING
173                        "sputrace: lost samples due to full buffer.\n");
174         }
175         spin_unlock(&sputrace_lock);
176
177         wake_up(&sputrace_wait);
178 }
179
180 static void spu_context_event(void *probe_private, void *call_data,
181                 const char *format, va_list *args)
182 {
183         struct spu_probe *p = probe_private;
184         struct spu_context *ctx;
185         struct spu *spu;
186
187         ctx = va_arg(*args, struct spu_context *);
188         spu = va_arg(*args, struct spu *);
189
190         sputrace_log_item(p->name, ctx, spu);
191 }
192
193 static void spu_context_nospu_event(void *probe_private, void *call_data,
194                 const char *format, va_list *args)
195 {
196         struct spu_probe *p = probe_private;
197         struct spu_context *ctx;
198
199         ctx = va_arg(*args, struct spu_context *);
200
201         sputrace_log_item(p->name, ctx, NULL);
202 }
203
204 struct spu_probe spu_probes[] = {
205         { "spu_bind_context__enter", "ctx %p spu %p", spu_context_event },
206         { "spu_unbind_context__enter", "ctx %p spu %p", spu_context_event },
207         { "spu_get_idle__enter", "ctx %p", spu_context_nospu_event },
208         { "spu_get_idle__found", "ctx %p spu %p", spu_context_event },
209         { "spu_get_idle__not_found", "ctx %p", spu_context_nospu_event },
210         { "spu_find_victim__enter", "ctx %p", spu_context_nospu_event },
211         { "spusched_tick__preempt", "ctx %p spu %p", spu_context_event },
212         { "spusched_tick__newslice", "ctx %p", spu_context_nospu_event },
213         { "spu_yield__enter", "ctx %p", spu_context_nospu_event },
214         { "spu_deactivate__enter", "ctx %p", spu_context_nospu_event },
215         { "__spu_deactivate__unload", "ctx %p spu %p", spu_context_event },
216         { "spufs_ps_fault__enter", "ctx %p", spu_context_nospu_event },
217         { "spufs_ps_fault__sleep", "ctx %p", spu_context_nospu_event },
218         { "spufs_ps_fault__wake", "ctx %p spu %p", spu_context_event },
219         { "spufs_ps_fault__insert", "ctx %p spu %p", spu_context_event },
220         { "spu_acquire_saved__enter", "ctx %p", spu_context_nospu_event },
221         { "destroy_spu_context__enter", "ctx %p", spu_context_nospu_event },
222         { "spufs_stop_callback__enter", "ctx %p spu %p", spu_context_event },
223 };
224
225 static int __init sputrace_init(void)
226 {
227         struct proc_dir_entry *entry;
228         int i, error = -ENOMEM;
229
230         sputrace_log = kcalloc(bufsize, sizeof(struct sputrace), GFP_KERNEL);
231         if (!sputrace_log)
232                 goto out;
233
234         entry = proc_create("sputrace", S_IRUSR, NULL, &sputrace_fops);
235         if (!entry)
236                 goto out_free_log;
237
238         for (i = 0; i < ARRAY_SIZE(spu_probes); i++) {
239                 struct spu_probe *p = &spu_probes[i];
240
241                 error = marker_probe_register(p->name, p->format,
242                                               p->probe_func, p);
243                 if (error)
244                         printk(KERN_INFO "Unable to register probe %s\n",
245                                         p->name);
246         }
247
248         return 0;
249
250 out_free_log:
251         kfree(sputrace_log);
252 out:
253         return -ENOMEM;
254 }
255
256 static void __exit sputrace_exit(void)
257 {
258         int i;
259
260         for (i = 0; i < ARRAY_SIZE(spu_probes); i++)
261                 marker_probe_unregister(spu_probes[i].name,
262                         spu_probes[i].probe_func, &spu_probes[i]);
263
264         remove_proc_entry("sputrace", NULL);
265         kfree(sputrace_log);
266         marker_synchronize_unregister();
267 }
268
269 module_init(sputrace_init);
270 module_exit(sputrace_exit);
271
272 MODULE_LICENSE("GPL");