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

TOMOYO Linux Cross Reference
Linux/kernel/gcov/fs.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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  *  This code exports profiling data as debugfs files to userspace.
  3  *
  4  *    Copyright IBM Corp. 2009
  5  *    Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
  6  *
  7  *    Uses gcc-internal data definitions.
  8  *    Based on the gcov-kernel patch by:
  9  *               Hubertus Franke <frankeh@us.ibm.com>
 10  *               Nigel Hinds <nhinds@us.ibm.com>
 11  *               Rajan Ravindran <rajancr@us.ibm.com>
 12  *               Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
 13  *               Paul Larson
 14  *               Yi CDL Yang
 15  */
 16 
 17 #define pr_fmt(fmt)     "gcov: " fmt
 18 
 19 #include <linux/init.h>
 20 #include <linux/module.h>
 21 #include <linux/debugfs.h>
 22 #include <linux/fs.h>
 23 #include <linux/list.h>
 24 #include <linux/string.h>
 25 #include <linux/slab.h>
 26 #include <linux/mutex.h>
 27 #include <linux/seq_file.h>
 28 #include "gcov.h"
 29 
 30 /**
 31  * struct gcov_node - represents a debugfs entry
 32  * @list: list head for child node list
 33  * @children: child nodes
 34  * @all: list head for list of all nodes
 35  * @parent: parent node
 36  * @loaded_info: array of pointers to profiling data sets for loaded object
 37  *   files.
 38  * @num_loaded: number of profiling data sets for loaded object files.
 39  * @unloaded_info: accumulated copy of profiling data sets for unloaded
 40  *   object files. Used only when gcov_persist=1.
 41  * @dentry: main debugfs entry, either a directory or data file
 42  * @links: associated symbolic links
 43  * @name: data file basename
 44  *
 45  * struct gcov_node represents an entity within the gcov/ subdirectory
 46  * of debugfs. There are directory and data file nodes. The latter represent
 47  * the actual synthesized data file plus any associated symbolic links which
 48  * are needed by the gcov tool to work correctly.
 49  */
 50 struct gcov_node {
 51         struct list_head list;
 52         struct list_head children;
 53         struct list_head all;
 54         struct gcov_node *parent;
 55         struct gcov_info **loaded_info;
 56         struct gcov_info *unloaded_info;
 57         struct dentry *dentry;
 58         struct dentry **links;
 59         int num_loaded;
 60         char name[0];
 61 };
 62 
 63 static const char objtree[] = OBJTREE;
 64 static const char srctree[] = SRCTREE;
 65 static struct gcov_node root_node;
 66 static struct dentry *reset_dentry;
 67 static LIST_HEAD(all_head);
 68 static DEFINE_MUTEX(node_lock);
 69 
 70 /* If non-zero, keep copies of profiling data for unloaded modules. */
 71 static int gcov_persist = 1;
 72 
 73 static int __init gcov_persist_setup(char *str)
 74 {
 75         unsigned long val;
 76 
 77         if (strict_strtoul(str, 0, &val)) {
 78                 pr_warning("invalid gcov_persist parameter '%s'\n", str);
 79                 return 0;
 80         }
 81         gcov_persist = val;
 82         pr_info("setting gcov_persist to %d\n", gcov_persist);
 83 
 84         return 1;
 85 }
 86 __setup("gcov_persist=", gcov_persist_setup);
 87 
 88 /*
 89  * seq_file.start() implementation for gcov data files. Note that the
 90  * gcov_iterator interface is designed to be more restrictive than seq_file
 91  * (no start from arbitrary position, etc.), to simplify the iterator
 92  * implementation.
 93  */
 94 static void *gcov_seq_start(struct seq_file *seq, loff_t *pos)
 95 {
 96         loff_t i;
 97 
 98         gcov_iter_start(seq->private);
 99         for (i = 0; i < *pos; i++) {
100                 if (gcov_iter_next(seq->private))
101                         return NULL;
102         }
103         return seq->private;
104 }
105 
106 /* seq_file.next() implementation for gcov data files. */
107 static void *gcov_seq_next(struct seq_file *seq, void *data, loff_t *pos)
108 {
109         struct gcov_iterator *iter = data;
110 
111         if (gcov_iter_next(iter))
112                 return NULL;
113         (*pos)++;
114 
115         return iter;
116 }
117 
118 /* seq_file.show() implementation for gcov data files. */
119 static int gcov_seq_show(struct seq_file *seq, void *data)
120 {
121         struct gcov_iterator *iter = data;
122 
123         if (gcov_iter_write(iter, seq))
124                 return -EINVAL;
125         return 0;
126 }
127 
128 static void gcov_seq_stop(struct seq_file *seq, void *data)
129 {
130         /* Unused. */
131 }
132 
133 static const struct seq_operations gcov_seq_ops = {
134         .start  = gcov_seq_start,
135         .next   = gcov_seq_next,
136         .show   = gcov_seq_show,
137         .stop   = gcov_seq_stop,
138 };
139 
140 /*
141  * Return a profiling data set associated with the given node. This is
142  * either a data set for a loaded object file or a data set copy in case
143  * all associated object files have been unloaded.
144  */
145 static struct gcov_info *get_node_info(struct gcov_node *node)
146 {
147         if (node->num_loaded > 0)
148                 return node->loaded_info[0];
149 
150         return node->unloaded_info;
151 }
152 
153 /*
154  * Return a newly allocated profiling data set which contains the sum of
155  * all profiling data associated with the given node.
156  */
157 static struct gcov_info *get_accumulated_info(struct gcov_node *node)
158 {
159         struct gcov_info *info;
160         int i = 0;
161 
162         if (node->unloaded_info)
163                 info = gcov_info_dup(node->unloaded_info);
164         else
165                 info = gcov_info_dup(node->loaded_info[i++]);
166         if (!info)
167                 return NULL;
168         for (; i < node->num_loaded; i++)
169                 gcov_info_add(info, node->loaded_info[i]);
170 
171         return info;
172 }
173 
174 /*
175  * open() implementation for gcov data files. Create a copy of the profiling
176  * data set and initialize the iterator and seq_file interface.
177  */
178 static int gcov_seq_open(struct inode *inode, struct file *file)
179 {
180         struct gcov_node *node = inode->i_private;
181         struct gcov_iterator *iter;
182         struct seq_file *seq;
183         struct gcov_info *info;
184         int rc = -ENOMEM;
185 
186         mutex_lock(&node_lock);
187         /*
188          * Read from a profiling data copy to minimize reference tracking
189          * complexity and concurrent access and to keep accumulating multiple
190          * profiling data sets associated with one node simple.
191          */
192         info = get_accumulated_info(node);
193         if (!info)
194                 goto out_unlock;
195         iter = gcov_iter_new(info);
196         if (!iter)
197                 goto err_free_info;
198         rc = seq_open(file, &gcov_seq_ops);
199         if (rc)
200                 goto err_free_iter_info;
201         seq = file->private_data;
202         seq->private = iter;
203 out_unlock:
204         mutex_unlock(&node_lock);
205         return rc;
206 
207 err_free_iter_info:
208         gcov_iter_free(iter);
209 err_free_info:
210         gcov_info_free(info);
211         goto out_unlock;
212 }
213 
214 /*
215  * release() implementation for gcov data files. Release resources allocated
216  * by open().
217  */
218 static int gcov_seq_release(struct inode *inode, struct file *file)
219 {
220         struct gcov_iterator *iter;
221         struct gcov_info *info;
222         struct seq_file *seq;
223 
224         seq = file->private_data;
225         iter = seq->private;
226         info = gcov_iter_get_info(iter);
227         gcov_iter_free(iter);
228         gcov_info_free(info);
229         seq_release(inode, file);
230 
231         return 0;
232 }
233 
234 /*
235  * Find a node by the associated data file name. Needs to be called with
236  * node_lock held.
237  */
238 static struct gcov_node *get_node_by_name(const char *name)
239 {
240         struct gcov_node *node;
241         struct gcov_info *info;
242 
243         list_for_each_entry(node, &all_head, all) {
244                 info = get_node_info(node);
245                 if (info && (strcmp(gcov_info_filename(info), name) == 0))
246                         return node;
247         }
248 
249         return NULL;
250 }
251 
252 /*
253  * Reset all profiling data associated with the specified node.
254  */
255 static void reset_node(struct gcov_node *node)
256 {
257         int i;
258 
259         if (node->unloaded_info)
260                 gcov_info_reset(node->unloaded_info);
261         for (i = 0; i < node->num_loaded; i++)
262                 gcov_info_reset(node->loaded_info[i]);
263 }
264 
265 static void remove_node(struct gcov_node *node);
266 
267 /*
268  * write() implementation for gcov data files. Reset profiling data for the
269  * corresponding file. If all associated object files have been unloaded,
270  * remove the debug fs node as well.
271  */
272 static ssize_t gcov_seq_write(struct file *file, const char __user *addr,
273                               size_t len, loff_t *pos)
274 {
275         struct seq_file *seq;
276         struct gcov_info *info;
277         struct gcov_node *node;
278 
279         seq = file->private_data;
280         info = gcov_iter_get_info(seq->private);
281         mutex_lock(&node_lock);
282         node = get_node_by_name(gcov_info_filename(info));
283         if (node) {
284                 /* Reset counts or remove node for unloaded modules. */
285                 if (node->num_loaded == 0)
286                         remove_node(node);
287                 else
288                         reset_node(node);
289         }
290         /* Reset counts for open file. */
291         gcov_info_reset(info);
292         mutex_unlock(&node_lock);
293 
294         return len;
295 }
296 
297 /*
298  * Given a string <path> representing a file path of format:
299  *   path/to/file.gcda
300  * construct and return a new string:
301  *   <dir/>path/to/file.<ext>
302  */
303 static char *link_target(const char *dir, const char *path, const char *ext)
304 {
305         char *target;
306         char *old_ext;
307         char *copy;
308 
309         copy = kstrdup(path, GFP_KERNEL);
310         if (!copy)
311                 return NULL;
312         old_ext = strrchr(copy, '.');
313         if (old_ext)
314                 *old_ext = '\0';
315         if (dir)
316                 target = kasprintf(GFP_KERNEL, "%s/%s.%s", dir, copy, ext);
317         else
318                 target = kasprintf(GFP_KERNEL, "%s.%s", copy, ext);
319         kfree(copy);
320 
321         return target;
322 }
323 
324 /*
325  * Construct a string representing the symbolic link target for the given
326  * gcov data file name and link type. Depending on the link type and the
327  * location of the data file, the link target can either point to a
328  * subdirectory of srctree, objtree or in an external location.
329  */
330 static char *get_link_target(const char *filename, const struct gcov_link *ext)
331 {
332         const char *rel;
333         char *result;
334 
335         if (strncmp(filename, objtree, strlen(objtree)) == 0) {
336                 rel = filename + strlen(objtree) + 1;
337                 if (ext->dir == SRC_TREE)
338                         result = link_target(srctree, rel, ext->ext);
339                 else
340                         result = link_target(objtree, rel, ext->ext);
341         } else {
342                 /* External compilation. */
343                 result = link_target(NULL, filename, ext->ext);
344         }
345 
346         return result;
347 }
348 
349 #define SKEW_PREFIX     ".tmp_"
350 
351 /*
352  * For a filename .tmp_filename.ext return filename.ext. Needed to compensate
353  * for filename skewing caused by the mod-versioning mechanism.
354  */
355 static const char *deskew(const char *basename)
356 {
357         if (strncmp(basename, SKEW_PREFIX, sizeof(SKEW_PREFIX) - 1) == 0)
358                 return basename + sizeof(SKEW_PREFIX) - 1;
359         return basename;
360 }
361 
362 /*
363  * Create links to additional files (usually .c and .gcno files) which the
364  * gcov tool expects to find in the same directory as the gcov data file.
365  */
366 static void add_links(struct gcov_node *node, struct dentry *parent)
367 {
368         char *basename;
369         char *target;
370         int num;
371         int i;
372 
373         for (num = 0; gcov_link[num].ext; num++)
374                 /* Nothing. */;
375         node->links = kcalloc(num, sizeof(struct dentry *), GFP_KERNEL);
376         if (!node->links)
377                 return;
378         for (i = 0; i < num; i++) {
379                 target = get_link_target(
380                                 gcov_info_filename(get_node_info(node)),
381                                 &gcov_link[i]);
382                 if (!target)
383                         goto out_err;
384                 basename = strrchr(target, '/');
385                 if (!basename)
386                         goto out_err;
387                 basename++;
388                 node->links[i] = debugfs_create_symlink(deskew(basename),
389                                                         parent, target);
390                 if (!node->links[i])
391                         goto out_err;
392                 kfree(target);
393         }
394 
395         return;
396 out_err:
397         kfree(target);
398         while (i-- > 0)
399                 debugfs_remove(node->links[i]);
400         kfree(node->links);
401         node->links = NULL;
402 }
403 
404 static const struct file_operations gcov_data_fops = {
405         .open           = gcov_seq_open,
406         .release        = gcov_seq_release,
407         .read           = seq_read,
408         .llseek         = seq_lseek,
409         .write          = gcov_seq_write,
410 };
411 
412 /* Basic initialization of a new node. */
413 static void init_node(struct gcov_node *node, struct gcov_info *info,
414                       const char *name, struct gcov_node *parent)
415 {
416         INIT_LIST_HEAD(&node->list);
417         INIT_LIST_HEAD(&node->children);
418         INIT_LIST_HEAD(&node->all);
419         if (node->loaded_info) {
420                 node->loaded_info[0] = info;
421                 node->num_loaded = 1;
422         }
423         node->parent = parent;
424         if (name)
425                 strcpy(node->name, name);
426 }
427 
428 /*
429  * Create a new node and associated debugfs entry. Needs to be called with
430  * node_lock held.
431  */
432 static struct gcov_node *new_node(struct gcov_node *parent,
433                                   struct gcov_info *info, const char *name)
434 {
435         struct gcov_node *node;
436 
437         node = kzalloc(sizeof(struct gcov_node) + strlen(name) + 1, GFP_KERNEL);
438         if (!node)
439                 goto err_nomem;
440         if (info) {
441                 node->loaded_info = kcalloc(1, sizeof(struct gcov_info *),
442                                            GFP_KERNEL);
443                 if (!node->loaded_info)
444                         goto err_nomem;
445         }
446         init_node(node, info, name, parent);
447         /* Differentiate between gcov data file nodes and directory nodes. */
448         if (info) {
449                 node->dentry = debugfs_create_file(deskew(node->name), 0600,
450                                         parent->dentry, node, &gcov_data_fops);
451         } else
452                 node->dentry = debugfs_create_dir(node->name, parent->dentry);
453         if (!node->dentry) {
454                 pr_warning("could not create file\n");
455                 kfree(node);
456                 return NULL;
457         }
458         if (info)
459                 add_links(node, parent->dentry);
460         list_add(&node->list, &parent->children);
461         list_add(&node->all, &all_head);
462 
463         return node;
464 
465 err_nomem:
466         kfree(node);
467         pr_warning("out of memory\n");
468         return NULL;
469 }
470 
471 /* Remove symbolic links associated with node. */
472 static void remove_links(struct gcov_node *node)
473 {
474         int i;
475 
476         if (!node->links)
477                 return;
478         for (i = 0; gcov_link[i].ext; i++)
479                 debugfs_remove(node->links[i]);
480         kfree(node->links);
481         node->links = NULL;
482 }
483 
484 /*
485  * Remove node from all lists and debugfs and release associated resources.
486  * Needs to be called with node_lock held.
487  */
488 static void release_node(struct gcov_node *node)
489 {
490         list_del(&node->list);
491         list_del(&node->all);
492         debugfs_remove(node->dentry);
493         remove_links(node);
494         kfree(node->loaded_info);
495         if (node->unloaded_info)
496                 gcov_info_free(node->unloaded_info);
497         kfree(node);
498 }
499 
500 /* Release node and empty parents. Needs to be called with node_lock held. */
501 static void remove_node(struct gcov_node *node)
502 {
503         struct gcov_node *parent;
504 
505         while ((node != &root_node) && list_empty(&node->children)) {
506                 parent = node->parent;
507                 release_node(node);
508                 node = parent;
509         }
510 }
511 
512 /*
513  * Find child node with given basename. Needs to be called with node_lock
514  * held.
515  */
516 static struct gcov_node *get_child_by_name(struct gcov_node *parent,
517                                            const char *name)
518 {
519         struct gcov_node *node;
520 
521         list_for_each_entry(node, &parent->children, list) {
522                 if (strcmp(node->name, name) == 0)
523                         return node;
524         }
525 
526         return NULL;
527 }
528 
529 /*
530  * write() implementation for reset file. Reset all profiling data to zero
531  * and remove nodes for which all associated object files are unloaded.
532  */
533 static ssize_t reset_write(struct file *file, const char __user *addr,
534                            size_t len, loff_t *pos)
535 {
536         struct gcov_node *node;
537 
538         mutex_lock(&node_lock);
539 restart:
540         list_for_each_entry(node, &all_head, all) {
541                 if (node->num_loaded > 0)
542                         reset_node(node);
543                 else if (list_empty(&node->children)) {
544                         remove_node(node);
545                         /* Several nodes may have gone - restart loop. */
546                         goto restart;
547                 }
548         }
549         mutex_unlock(&node_lock);
550 
551         return len;
552 }
553 
554 /* read() implementation for reset file. Unused. */
555 static ssize_t reset_read(struct file *file, char __user *addr, size_t len,
556                           loff_t *pos)
557 {
558         /* Allow read operation so that a recursive copy won't fail. */
559         return 0;
560 }
561 
562 static const struct file_operations gcov_reset_fops = {
563         .write  = reset_write,
564         .read   = reset_read,
565         .llseek = noop_llseek,
566 };
567 
568 /*
569  * Create a node for a given profiling data set and add it to all lists and
570  * debugfs. Needs to be called with node_lock held.
571  */
572 static void add_node(struct gcov_info *info)
573 {
574         char *filename;
575         char *curr;
576         char *next;
577         struct gcov_node *parent;
578         struct gcov_node *node;
579 
580         filename = kstrdup(gcov_info_filename(info), GFP_KERNEL);
581         if (!filename)
582                 return;
583         parent = &root_node;
584         /* Create directory nodes along the path. */
585         for (curr = filename; (next = strchr(curr, '/')); curr = next + 1) {
586                 if (curr == next)
587                         continue;
588                 *next = 0;
589                 if (strcmp(curr, ".") == 0)
590                         continue;
591                 if (strcmp(curr, "..") == 0) {
592                         if (!parent->parent)
593                                 goto err_remove;
594                         parent = parent->parent;
595                         continue;
596                 }
597                 node = get_child_by_name(parent, curr);
598                 if (!node) {
599                         node = new_node(parent, NULL, curr);
600                         if (!node)
601                                 goto err_remove;
602                 }
603                 parent = node;
604         }
605         /* Create file node. */
606         node = new_node(parent, info, curr);
607         if (!node)
608                 goto err_remove;
609 out:
610         kfree(filename);
611         return;
612 
613 err_remove:
614         remove_node(parent);
615         goto out;
616 }
617 
618 /*
619  * Associate a profiling data set with an existing node. Needs to be called
620  * with node_lock held.
621  */
622 static void add_info(struct gcov_node *node, struct gcov_info *info)
623 {
624         struct gcov_info **loaded_info;
625         int num = node->num_loaded;
626 
627         /*
628          * Prepare new array. This is done first to simplify cleanup in
629          * case the new data set is incompatible, the node only contains
630          * unloaded data sets and there's not enough memory for the array.
631          */
632         loaded_info = kcalloc(num + 1, sizeof(struct gcov_info *), GFP_KERNEL);
633         if (!loaded_info) {
634                 pr_warning("could not add '%s' (out of memory)\n",
635                            gcov_info_filename(info));
636                 return;
637         }
638         memcpy(loaded_info, node->loaded_info,
639                num * sizeof(struct gcov_info *));
640         loaded_info[num] = info;
641         /* Check if the new data set is compatible. */
642         if (num == 0) {
643                 /*
644                  * A module was unloaded, modified and reloaded. The new
645                  * data set replaces the copy of the last one.
646                  */
647                 if (!gcov_info_is_compatible(node->unloaded_info, info)) {
648                         pr_warning("discarding saved data for %s "
649                                    "(incompatible version)\n",
650                                    gcov_info_filename(info));
651                         gcov_info_free(node->unloaded_info);
652                         node->unloaded_info = NULL;
653                 }
654         } else {
655                 /*
656                  * Two different versions of the same object file are loaded.
657                  * The initial one takes precedence.
658                  */
659                 if (!gcov_info_is_compatible(node->loaded_info[0], info)) {
660                         pr_warning("could not add '%s' (incompatible "
661                                    "version)\n", gcov_info_filename(info));
662                         kfree(loaded_info);
663                         return;
664                 }
665         }
666         /* Overwrite previous array. */
667         kfree(node->loaded_info);
668         node->loaded_info = loaded_info;
669         node->num_loaded = num + 1;
670 }
671 
672 /*
673  * Return the index of a profiling data set associated with a node.
674  */
675 static int get_info_index(struct gcov_node *node, struct gcov_info *info)
676 {
677         int i;
678 
679         for (i = 0; i < node->num_loaded; i++) {
680                 if (node->loaded_info[i] == info)
681                         return i;
682         }
683         return -ENOENT;
684 }
685 
686 /*
687  * Save the data of a profiling data set which is being unloaded.
688  */
689 static void save_info(struct gcov_node *node, struct gcov_info *info)
690 {
691         if (node->unloaded_info)
692                 gcov_info_add(node->unloaded_info, info);
693         else {
694                 node->unloaded_info = gcov_info_dup(info);
695                 if (!node->unloaded_info) {
696                         pr_warning("could not save data for '%s' "
697                                    "(out of memory)\n",
698                                    gcov_info_filename(info));
699                 }
700         }
701 }
702 
703 /*
704  * Disassociate a profiling data set from a node. Needs to be called with
705  * node_lock held.
706  */
707 static void remove_info(struct gcov_node *node, struct gcov_info *info)
708 {
709         int i;
710 
711         i = get_info_index(node, info);
712         if (i < 0) {
713                 pr_warning("could not remove '%s' (not found)\n",
714                            gcov_info_filename(info));
715                 return;
716         }
717         if (gcov_persist)
718                 save_info(node, info);
719         /* Shrink array. */
720         node->loaded_info[i] = node->loaded_info[node->num_loaded - 1];
721         node->num_loaded--;
722         if (node->num_loaded > 0)
723                 return;
724         /* Last loaded data set was removed. */
725         kfree(node->loaded_info);
726         node->loaded_info = NULL;
727         node->num_loaded = 0;
728         if (!node->unloaded_info)
729                 remove_node(node);
730 }
731 
732 /*
733  * Callback to create/remove profiling files when code compiled with
734  * -fprofile-arcs is loaded/unloaded.
735  */
736 void gcov_event(enum gcov_action action, struct gcov_info *info)
737 {
738         struct gcov_node *node;
739 
740         mutex_lock(&node_lock);
741         node = get_node_by_name(gcov_info_filename(info));
742         switch (action) {
743         case GCOV_ADD:
744                 if (node)
745                         add_info(node, info);
746                 else
747                         add_node(info);
748                 break;
749         case GCOV_REMOVE:
750                 if (node)
751                         remove_info(node, info);
752                 else {
753                         pr_warning("could not remove '%s' (not found)\n",
754                                    gcov_info_filename(info));
755                 }
756                 break;
757         }
758         mutex_unlock(&node_lock);
759 }
760 
761 /* Create debugfs entries. */
762 static __init int gcov_fs_init(void)
763 {
764         int rc = -EIO;
765 
766         init_node(&root_node, NULL, NULL, NULL);
767         /*
768          * /sys/kernel/debug/gcov will be parent for the reset control file
769          * and all profiling files.
770          */
771         root_node.dentry = debugfs_create_dir("gcov", NULL);
772         if (!root_node.dentry)
773                 goto err_remove;
774         /*
775          * Create reset file which resets all profiling counts when written
776          * to.
777          */
778         reset_dentry = debugfs_create_file("reset", 0600, root_node.dentry,
779                                            NULL, &gcov_reset_fops);
780         if (!reset_dentry)
781                 goto err_remove;
782         /* Replay previous events to get our fs hierarchy up-to-date. */
783         gcov_enable_events();
784         return 0;
785 
786 err_remove:
787         pr_err("init failed\n");
788         if (root_node.dentry)
789                 debugfs_remove(root_node.dentry);
790 
791         return rc;
792 }
793 device_initcall(gcov_fs_init);
794 

~ [ 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