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