~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_stat.c

Version: ~ [ linux-5.15-rc6 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Infrastructure for statistic tracing (histogram output).
  3  *
  4  * Copyright (C) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>
  5  *
  6  * Based on the code from trace_branch.c which is
  7  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
  8  *
  9  */
 10 
 11 
 12 #include <linux/list.h>
 13 #include <linux/slab.h>
 14 #include <linux/rbtree.h>
 15 #include <linux/tracefs.h>
 16 #include "trace_stat.h"
 17 #include "trace.h"
 18 
 19 
 20 /*
 21  * List of stat red-black nodes from a tracer
 22  * We use a such tree to sort quickly the stat
 23  * entries from the tracer.
 24  */
 25 struct stat_node {
 26         struct rb_node          node;
 27         void                    *stat;
 28 };
 29 
 30 /* A stat session is the stats output in one file */
 31 struct stat_session {
 32         struct list_head        session_list;
 33         struct tracer_stat      *ts;
 34         struct rb_root          stat_root;
 35         struct mutex            stat_mutex;
 36         struct dentry           *file;
 37 };
 38 
 39 /* All of the sessions currently in use. Each stat file embed one session */
 40 static LIST_HEAD(all_stat_sessions);
 41 static DEFINE_MUTEX(all_stat_sessions_mutex);
 42 
 43 /* The root directory for all stat files */
 44 static struct dentry            *stat_dir;
 45 
 46 static void __reset_stat_session(struct stat_session *session)
 47 {
 48         struct stat_node *snode, *n;
 49 
 50         rbtree_postorder_for_each_entry_safe(snode, n, &session->stat_root, node) {
 51                 if (session->ts->stat_release)
 52                         session->ts->stat_release(snode->stat);
 53                 kfree(snode);
 54         }
 55 
 56         session->stat_root = RB_ROOT;
 57 }
 58 
 59 static void reset_stat_session(struct stat_session *session)
 60 {
 61         mutex_lock(&session->stat_mutex);
 62         __reset_stat_session(session);
 63         mutex_unlock(&session->stat_mutex);
 64 }
 65 
 66 static void destroy_session(struct stat_session *session)
 67 {
 68         tracefs_remove(session->file);
 69         __reset_stat_session(session);
 70         mutex_destroy(&session->stat_mutex);
 71         kfree(session);
 72 }
 73 
 74 typedef int (*cmp_stat_t)(void *, void *);
 75 
 76 static int insert_stat(struct rb_root *root, void *stat, cmp_stat_t cmp)
 77 {
 78         struct rb_node **new = &(root->rb_node), *parent = NULL;
 79         struct stat_node *data;
 80 
 81         data = kzalloc(sizeof(*data), GFP_KERNEL);
 82         if (!data)
 83                 return -ENOMEM;
 84         data->stat = stat;
 85 
 86         /*
 87          * Figure out where to put new node
 88          * This is a descendent sorting
 89          */
 90         while (*new) {
 91                 struct stat_node *this;
 92                 int result;
 93 
 94                 this = container_of(*new, struct stat_node, node);
 95                 result = cmp(data->stat, this->stat);
 96 
 97                 parent = *new;
 98                 if (result >= 0)
 99                         new = &((*new)->rb_left);
100                 else
101                         new = &((*new)->rb_right);
102         }
103 
104         rb_link_node(&data->node, parent, new);
105         rb_insert_color(&data->node, root);
106         return 0;
107 }
108 
109 /*
110  * For tracers that don't provide a stat_cmp callback.
111  * This one will force an insertion as right-most node
112  * in the rbtree.
113  */
114 static int dummy_cmp(void *p1, void *p2)
115 {
116         return -1;
117 }
118 
119 /*
120  * Initialize the stat rbtree at each trace_stat file opening.
121  * All of these copies and sorting are required on all opening
122  * since the stats could have changed between two file sessions.
123  */
124 static int stat_seq_init(struct stat_session *session)
125 {
126         struct tracer_stat *ts = session->ts;
127         struct rb_root *root = &session->stat_root;
128         void *stat;
129         int ret = 0;
130         int i;
131 
132         mutex_lock(&session->stat_mutex);
133         __reset_stat_session(session);
134 
135         if (!ts->stat_cmp)
136                 ts->stat_cmp = dummy_cmp;
137 
138         stat = ts->stat_start(ts);
139         if (!stat)
140                 goto exit;
141 
142         ret = insert_stat(root, stat, ts->stat_cmp);
143         if (ret)
144                 goto exit;
145 
146         /*
147          * Iterate over the tracer stat entries and store them in an rbtree.
148          */
149         for (i = 1; ; i++) {
150                 stat = ts->stat_next(stat, i);
151 
152                 /* End of insertion */
153                 if (!stat)
154                         break;
155 
156                 ret = insert_stat(root, stat, ts->stat_cmp);
157                 if (ret)
158                         goto exit_free_rbtree;
159         }
160 
161 exit:
162         mutex_unlock(&session->stat_mutex);
163         return ret;
164 
165 exit_free_rbtree:
166         __reset_stat_session(session);
167         mutex_unlock(&session->stat_mutex);
168         return ret;
169 }
170 
171 
172 static void *stat_seq_start(struct seq_file *s, loff_t *pos)
173 {
174         struct stat_session *session = s->private;
175         struct rb_node *node;
176         int n = *pos;
177         int i;
178 
179         /* Prevent from tracer switch or rbtree modification */
180         mutex_lock(&session->stat_mutex);
181 
182         /* If we are in the beginning of the file, print the headers */
183         if (session->ts->stat_headers) {
184                 if (n == 0)
185                         return SEQ_START_TOKEN;
186                 n--;
187         }
188 
189         node = rb_first(&session->stat_root);
190         for (i = 0; node && i < n; i++)
191                 node = rb_next(node);
192 
193         return node;
194 }
195 
196 static void *stat_seq_next(struct seq_file *s, void *p, loff_t *pos)
197 {
198         struct stat_session *session = s->private;
199         struct rb_node *node = p;
200 
201         (*pos)++;
202 
203         if (p == SEQ_START_TOKEN)
204                 return rb_first(&session->stat_root);
205 
206         return rb_next(node);
207 }
208 
209 static void stat_seq_stop(struct seq_file *s, void *p)
210 {
211         struct stat_session *session = s->private;
212         mutex_unlock(&session->stat_mutex);
213 }
214 
215 static int stat_seq_show(struct seq_file *s, void *v)
216 {
217         struct stat_session *session = s->private;
218         struct stat_node *l = container_of(v, struct stat_node, node);
219 
220         if (v == SEQ_START_TOKEN)
221                 return session->ts->stat_headers(s);
222 
223         return session->ts->stat_show(s, l->stat);
224 }
225 
226 static const struct seq_operations trace_stat_seq_ops = {
227         .start          = stat_seq_start,
228         .next           = stat_seq_next,
229         .stop           = stat_seq_stop,
230         .show           = stat_seq_show
231 };
232 
233 /* The session stat is refilled and resorted at each stat file opening */
234 static int tracing_stat_open(struct inode *inode, struct file *file)
235 {
236         int ret;
237         struct seq_file *m;
238         struct stat_session *session = inode->i_private;
239 
240         ret = stat_seq_init(session);
241         if (ret)
242                 return ret;
243 
244         ret = seq_open(file, &trace_stat_seq_ops);
245         if (ret) {
246                 reset_stat_session(session);
247                 return ret;
248         }
249 
250         m = file->private_data;
251         m->private = session;
252         return ret;
253 }
254 
255 /*
256  * Avoid consuming memory with our now useless rbtree.
257  */
258 static int tracing_stat_release(struct inode *i, struct file *f)
259 {
260         struct stat_session *session = i->i_private;
261 
262         reset_stat_session(session);
263 
264         return seq_release(i, f);
265 }
266 
267 static const struct file_operations tracing_stat_fops = {
268         .open           = tracing_stat_open,
269         .read           = seq_read,
270         .llseek         = seq_lseek,
271         .release        = tracing_stat_release
272 };
273 
274 static int tracing_stat_init(void)
275 {
276         struct dentry *d_tracing;
277 
278         d_tracing = tracing_init_dentry();
279         if (IS_ERR(d_tracing))
280                 return 0;
281 
282         stat_dir = tracefs_create_dir("trace_stat", d_tracing);
283         if (!stat_dir)
284                 pr_warning("Could not create tracefs "
285                            "'trace_stat' entry\n");
286         return 0;
287 }
288 
289 static int init_stat_file(struct stat_session *session)
290 {
291         if (!stat_dir && tracing_stat_init())
292                 return -ENODEV;
293 
294         session->file = tracefs_create_file(session->ts->name, 0644,
295                                             stat_dir,
296                                             session, &tracing_stat_fops);
297         if (!session->file)
298                 return -ENOMEM;
299         return 0;
300 }
301 
302 int register_stat_tracer(struct tracer_stat *trace)
303 {
304         struct stat_session *session, *node;
305         int ret;
306 
307         if (!trace)
308                 return -EINVAL;
309 
310         if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
311                 return -EINVAL;
312 
313         /* Already registered? */
314         mutex_lock(&all_stat_sessions_mutex);
315         list_for_each_entry(node, &all_stat_sessions, session_list) {
316                 if (node->ts == trace) {
317                         mutex_unlock(&all_stat_sessions_mutex);
318                         return -EINVAL;
319                 }
320         }
321         mutex_unlock(&all_stat_sessions_mutex);
322 
323         /* Init the session */
324         session = kzalloc(sizeof(*session), GFP_KERNEL);
325         if (!session)
326                 return -ENOMEM;
327 
328         session->ts = trace;
329         INIT_LIST_HEAD(&session->session_list);
330         mutex_init(&session->stat_mutex);
331 
332         ret = init_stat_file(session);
333         if (ret) {
334                 destroy_session(session);
335                 return ret;
336         }
337 
338         /* Register */
339         mutex_lock(&all_stat_sessions_mutex);
340         list_add_tail(&session->session_list, &all_stat_sessions);
341         mutex_unlock(&all_stat_sessions_mutex);
342 
343         return 0;
344 }
345 
346 void unregister_stat_tracer(struct tracer_stat *trace)
347 {
348         struct stat_session *node, *tmp;
349 
350         mutex_lock(&all_stat_sessions_mutex);
351         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
352                 if (node->ts == trace) {
353                         list_del(&node->session_list);
354                         destroy_session(node);
355                         break;
356                 }
357         }
358         mutex_unlock(&all_stat_sessions_mutex);
359 }
360 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp