perf/sdt: SDT events listing/probing

This patch adds a new sub-command to perf : sdt-cache.

sdt-cache command can be used to add, remove and dump SDT events. This patch adds support to only "add" the SDT events. The rest of the patches add support to rest of them.

When user invokes "perf sdt-cache add <file-name>", two hash tables are
created: file_hash list and event_hash list. A typical entry in a file_hash table looks like:

            file hash      file_sdt_ent     file_sdt_ent
            |---------|   ---------------   -------------
            | list  ==|===|=>file_list =|===|=>file_list=|==..
key = 644 =>|         |   | sbuild_id   |   | sbuild_id  |
            |---------|   | name        |   | name       |
            |	      |   | sdt_list    |   | sdt_list   |
key = 645 =>| list    |   |   ||        |   |    ||      |
            |---------|   ---------------   --------------
	        ||            ||                 || Connected to SDT notes

---------------
| note_list |
sdt_note| name |
| provider |
-----||--------
connected to other SDT notes

Each entry of the file_hash table is a list which connects to file_list in file_sdt_ent. file_sdt_ent is allocated per file whenever a file is mapped to file_hash list. File name serves as the key to this hash table. If a file is added to this hash list, a file_sdt_ent is allocated and a list of SDT events in that file is created and assigned to sdt_list of file_sdt_ent.

Example usage :

# ./perf sdt-cache --add /home/user_app

4 events added for /home/user_app!

# ./perf sdt-cache --add /lib64/libc.so.6

8 events added for /usr/lib64/libc-2.16.so!

tools/perf/util/sdt.c new file +43 -0

new file mode 100644
index 0000000..0b56210
@@ -0,0 +1,665 @@
+/*
+ * util/sdt.c
+ * This contains the relevant functions needed to find the SDT events
+ * in a binary and adding them to a cache.
+ *
+ * TODOS:
+ * - Listing SDT events in most of the binaries present in the system.
+ * - Looking into directories provided by the user for binaries with SDTs,
+ * etc.
+ * - Support SDT event arguments.
+ * - Support SDT event semaphores.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "parse-events.h"
+#include "probe-event.h"
+#include "linux/list.h"
+#include "symbol.h"
+#include "build-id.h"
+
+struct file_info {
+	char *name;                             /* File name */
+	char sbuild_id[BUILD_ID_SIZE * 2 + 1];  /* Build id of the file */
+};
+
+/**
+ * get_hash_key: calculates the key to hash tables
+ * @str: input string
+ *
+ * adds the ascii values for all the chars in @str, multiplies with a prime
+ * and finds the modulo with HASH_TABLE_SIZE.
+ *
+ * Return : An integer key

tools/perf/util/sdt.c new file +40 -0

+
+	return key;
+}
+
+/**
+ * sdt_err: print SDT related error
+ * @val: error code
+ * @target: input file
+ *
+ * Display error corresponding to @val for file @target
+ */
+static int sdt_err(int val, const char *target)
+{
+	switch (-val) {
+	case 0:
+		break;
+	case ENOENT:
+		/* Absence of SDT markers */
+		pr_err("%s: No SDT events found\n", target);
+		break;
+	case EBADF:
+		pr_err("%s: Bad file name\n", target);
+		break;
+	default:
+		pr_err("%s\n", strerror(val));
+	}
+
+	return val;
+}
+
+/**
+ * cleanup_sdt_note_list : free the sdt notes' list
+ * @sdt_notes: sdt notes' list
+ *
+ * Free up the SDT notes in @sdt_notes.
+ */
+static void cleanup_sdt_note_list(struct list_head *sdt_notes)
+{
+	struct sdt_note *tmp, *pos;
+

tools/perf/util/sdt.c new file +22 -0

+
+/**
+ * file_list_entry__init: Initialize a file_list_entry
+ * @fse: file_list_entry
+ * @file: file information
+ *
+ * Initializes @fse with the build id of a @file.
+ */
+static void file_list_entry__init(struct file_sdt_ent *fse,
+				 struct file_info *file)
+{
+	strcpy(fse->sbuild_id, file->sbuild_id);
+	INIT_LIST_HEAD(&fse->file_list);
+	INIT_LIST_HEAD(&fse->sdt_list);
+}
+
+/**
+ * sdt_events__get_count: Counts the number of sdt events
+ * @start: list_head to sdt_notes list
+ *
+ * Returns the number of SDT notes in a list
+ */

tools/perf/util/sdt.c new file +72 -0

+
+/**
+ * file_hash_list__add: add an entry to file_hash_list
+ * @sdt_notes: list of sdt_notes
+ * @file: file name and build id
+ * @file_hash: hash table for file and sdt notes
+ *
+ * Get the key corresponding to @file->name. Fetch the entry
+ * for that key. Build a file_list_entry fse, assign the SDT notes
+ * to it and then assign fse to the fetched entry into the hash.
+ */
+static int file_hash_list__add(struct list_head *sdt_notes,
+				struct file_info *file,
+				struct hash_list *file_hash)
+{
+	struct file_sdt_ent *fse;
+	struct list_head *ent_head;
+	int key, nr_evs;
+
+	key = get_hash_key(file->name);
+	ent_head = &file_hash->ent[key].list;
+
+	/* Initialize the file entry */
+	fse = (struct file_sdt_ent *)malloc(sizeof(struct file_sdt_ent));
+	if (!fse)
+		return -ENOMEM;
+	file_list_entry__init(fse, file);
+	nr_evs = sdt_events__get_count(sdt_notes);
+	list_splice(sdt_notes, &fse->sdt_list);
+
+	printf("%d events added for %s\n", nr_evs, file->name);
+	strcpy(fse->name, file->name);
+
+	/* Add the file to the file hash entry */
+	list_add(&fse->file_list, ent_head);
+
+	return MOD;
+}
+
+/**
+ * file_hash_list__remove: Remove a file entry from the file_hash table
+ * @file_hash: file_hash_table
+ * @target: file name
+ *
+ * Removes the entries from file_hash table corresponding to @target.
+ * Gets the key from @target. Also frees up the SDT events for that
+ * file.
+ */
+static int file_hash_list__remove(struct hash_list *file_hash,
+				   const char *target)
+{
+	struct file_sdt_ent *fse, *tmp1;
+	struct list_head *sdt_head, *ent_head;
+	struct sdt_note *sdt_ptr, *tmp2;
+
+	char *res_path;
+	int key, nr_del = 0;
+
+	key = get_hash_key(target);
+	ent_head = &file_hash->ent[key].list;
+
+	res_path = realpath(target, NULL);
+	if (!res_path)
+		return -ENOMEM;
+
+	if (list_empty(ent_head))
+		return 0;
+
+	/* Got the file hash entry */
+	list_for_each_entry_safe(fse, tmp1, ent_head, file_list) {
+		sdt_head = &fse->sdt_list;
+		if (strcmp(res_path, fse->name))

tools/perf/util/sdt.c new file +45 -0

+		list_del(&fse->file_list);
+		list_del(&fse->sdt_list);
+		free(fse);
+	}
+
+	return nr_del;
+}
+/**
+ * file_hash_list__entry_exists: Checks if a file is already present
+ * @file_hash: file_hash table
+ * @file: file name and build id to check
+ *
+ * Obtains the key from @file->name, fetches the correct entry,
+ * and goes through the chain to find out the correct file list entry.
+ * Compares the build id, if they match, return true, else, false.
+ */
+static bool file_hash_list__entry_exists(struct hash_list *file_hash,
+					  struct file_info *file)
+{
+	struct file_sdt_ent *fse;
+	struct list_head *ent_head;
+	int key;
+
+	key = get_hash_key(file->name);
+	ent_head = &file_hash->ent[key].list;
+	if (list_empty(ent_head))
+		return false;
+
+	list_for_each_entry(fse, ent_head, file_list) {
+		if (!strcmp(file->name, fse->name)) {
+			if (!strcmp(file->sbuild_id, fse->sbuild_id))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * copy_delim: copy till a character
+ * @src: source string
+ * @target: dest string
+ * @delim: till this character
+ * @len: length of @target
+ * @end: end of @src

tools/perf/util/sdt.c new file +7 -0

+
+/**
+ * sdt_note__read: Parse SDT note info
+ * @ptr: raw data
+ * @sdt_list: empty list
+ * @end: end of the raw data
+ *

tools/perf/util/sdt.c new file +51 -0

+		sn = (struct sdt_note *)malloc(sizeof(struct sdt_note));
+		if (!sn)
+			return;
+		INIT_LIST_HEAD(&sn->note_list);
+		sn->name = (char *)malloc(PATH_MAX);
+		if (!sn->name)
+			return;
+		sn->provider = (char *)malloc(PATH_MAX);
+		if (!sn->provider)
+			return;
+		/* Extract the provider name */
+		len = copy_delim(*ptr, sn->provider, DELIM, PATH_MAX, end);
+		*ptr += len;
+
+		/* Extract the note name */
+		len = copy_delim(*ptr, sn->name, DELIM, PATH_MAX, end);
+		*ptr += len;
+
+		/* Extract the note's location */
+		len = copy_delim(*ptr, addr , DELIM, MAX_ADDR, end);
+		*ptr += len;
+		sscanf(addr, "%lx", &sn->addr.a64[0]);
+
+		/* Extract the sem location */
+		len = copy_delim(*ptr, addr , DELIM, MAX_ADDR, end);
+		*ptr += len;
+		sscanf(addr, "%lx", &sn->addr.a64[2]);
+		list_add(&sn->note_list, sdt_list);
+
+		/* If the entries for this file are finished */
+		if (**ptr == DELIM)
+			break;
+	}
+}
+
+/**
+ * file_hash_list__populate: Fill up the file hash table
+ * @file_hash: empty file hash table
+ * @data: raw cache data
+ * @size: size of data
+ *
+ * Find out the end of data with help of @size. Start parsing @data.
+ * In the outer loop, it reads the 'key' delimited by "::-". In the inner
+ * loop, it reads the file name, build id and calls sdt_note__read() to
+ * read the SDT notes. Multiple entries for the same key are delimited
+ * by "::". Then, it assigns the file name, build id and SDT notes to the
+ * list entry corresponding to 'key'.
+ */
+static void file_hash_list__populate(struct hash_list *file_hash, char *data,
+				     off_t size)
+{

tools/perf/util/sdt.c new file +35 -0

+		/* Obtain the key */
+		len = copy_delim(ptr, tmp, DELIM, PATH_MAX, end);
+		ptr += len;
+		key = atoi(tmp);
+		/* Obtain the file_hash list entry */
+		ent_head = &file_hash->ent[key].list;
+		while (1) {
+			fse = (struct file_sdt_ent *)
+				malloc(sizeof(struct file_sdt_ent));
+			if (!fse)
+				return;
+			INIT_LIST_HEAD(&fse->file_list);
+			INIT_LIST_HEAD(&fse->sdt_list);
+			/* Obtain the file name */
+			len = copy_delim(ptr, fse->name, DELIM,
+					 sizeof(fse->name), end);
+			ptr += len;
+			/* Obtain the build id */
+			len = copy_delim(ptr, fse->sbuild_id, DELIM,
+					 sizeof(fse->sbuild_id), end);
+			ptr += len;
+			sdt_note__read(&ptr, &fse->sdt_list, end);
+
+			list_add(&fse->file_list, ent_head);
+
+			/* Check for another file entry */
+			if ((*ptr++ == DELIM) && (*ptr == '-'))
+				break;
+		}
+		if (ptr == end)
+			break;
+		else
+			ptr++;
+
+	} while (1);

tools/perf/util/sdt.c new file +26 -0

+{
+	struct stat sb;
+	char *data;
+	int fd, i, ret;
+
+	for (i = 0; i < HASH_TABLE_SIZE; i++)
+		INIT_LIST_HEAD(&file_hash->ent[i].list);
+
+	fd = open(SDT_CACHE_DIR SDT_FILE_CACHE, O_RDONLY);
+	if (fd == -1)
+		return;
+
+	ret = fstat(fd, &sb);
+	if (ret == -1) {
+		pr_err("fstat : error\n");
+		return;
+	}
+
+	if (!S_ISREG(sb.st_mode)) {
+		pr_err("%s is not a regular file\n", SDT_CACHE_DIR
+		       SDT_FILE_CACHE);
+		return;
+	}
+	/* Is size of the cache zero ?*/
+	if (!sb.st_size)
+		return;

tools/perf/util/sdt.c new file +74 -0

+	ret = close(fd);
+	if (ret == -1) {
+		pr_err("Error in close\n");
+		return;
+	}
+
+	/* Populate the hash list */
+	file_hash_list__populate(file_hash, data, sb.st_size);
+	ret = munmap(data, sb.st_size);
+	if (ret == -1)
+		pr_err("Error in munmap\n");
+}
+
+/**
+ * file_hash_list__cleanup: Free up all the space for file_hash list
+ * @file_hash: file_hash table
+ */
+static void file_hash_list__cleanup(struct hash_list *file_hash)
+{
+	struct file_sdt_ent *file_pos, *tmp;
+	struct list_head *ent_head, *sdt_head;
+	int i;
+
+	/* Go through all the entries */
+	for (i = 0; i < HASH_TABLE_SIZE; i++) {
+		ent_head = &file_hash->ent[i].list;
+		if (list_empty(ent_head))
+			continue;
+
+		list_for_each_entry_safe(file_pos, tmp, ent_head, file_list) {
+			sdt_head = &file_pos->sdt_list;
+			/* Cleanup the corresponding SDT notes' list */
+			cleanup_sdt_note_list(sdt_head);
+			list_del(&file_pos->file_list);
+			list_del(&file_pos->sdt_list);
+			free(file_pos);
+		}
+	}
+}
+
+/**
+ * add_to_hash_list: add an entry to file_hash_list
+ * @file_hash: file hash table
+ * @target: file name
+ *
+ * Does a sanity check for the @target, finds out its build id,
+ * checks if @target is already present in file hash list. If not present,
+ * delete any stale entries with this file name (i.e., entries matching this
+ * file name but having older build ids). And then, adds the file entry to
+ * file hash list and also updates the SDT events in the event hash list.
+ */
+static int add_to_hash_list(struct hash_list *file_hash, const char *target)
+{
+	struct file_info *file;
+	int ret = 0;
+	u8 build_id[BUILD_ID_SIZE];
+
+	LIST_HEAD(sdt_notes);
+
+	file = (struct file_info *)malloc(sizeof(struct file_info));
+	if (!file)
+		return -ENOMEM;
+
+	file->name = realpath(target, NULL);
+	if (!file->name) {
+		ret = -EBADF;
+		pr_err("%s: Bad file name!\n", target);
+		goto out;
+	}
+
+	symbol__elf_init();
+	if (filename__read_build_id(file->name, &build_id,
+				    sizeof(build_id)) < 0) {
+		pr_err("Couldn't read build-id in %s\n", file->name);

tools/perf/util/sdt.c new file +51 -0

+		goto out;
+	}
+
+	/*
+	 * This will also remove any stale entries (if any) from the event hash.
+	 * Stale entries will have the same file name but older build ids.
+	 */
+	file_hash_list__remove(file_hash, file->name);
+	ret = get_sdt_note_list(&sdt_notes, file->name);
+	if (!ret) {
+		/* Add the entry to file hash list */
+		ret = file_hash_list__add(&sdt_notes, file, file_hash);
+	} else {
+		sdt_err(ret, target);
+	}
+
+out:
+	free(file->name);
+	free(file);
+	return ret;
+}
+
+/**
+ * file_hash_list__flush: Flush the file_hash list to cache
+ * @file_hash: file_hash list
+ * @fcache: opened SDT events cache
+ *
+ * Iterate through all the entries of @file_hash and flush them
+ * onto fcache.
+ * The complete file hash list is flushed into the cache. First
+ * write the key for non-empty entry and then file entries for that
+ * key, and then the SDT notes. The delimiter used is ':'.
+ */
+static void file_hash_list__flush(struct hash_list *file_hash,
+				  FILE *fcache)
+{
+	struct file_sdt_ent *file_pos;
+	struct list_head *ent_head, *sdt_head;
+	struct sdt_note *sdt_ptr;
+	int i;
+
+	/* Go through all entries */
+	for (i = 0; i < HASH_TABLE_SIZE; i++) {
+		/* Obtain the list head */
+		ent_head = &file_hash->ent[i].list;
+		/* Empty ? */
+		if (list_empty(ent_head))
+			continue;
+		/* ':' are used here as delimiters */
+		fprintf(fcache, "%d:", i);
+		list_for_each_entry(file_pos, ent_head, file_list) {

tools/perf/util/sdt.c new file +69 -0

+		}
+		/* '-' marks the end of entries for that key */
+		fprintf(fcache, "-");
+	}
+
+}
+
+/**
+ * flush_hash_list_to_cache: Flush everything from file_hash to disk
+ * @file_hash: file_hash list
+ *
+ * Opens a cache and calls file_hash_list__flush() to dump everything
+ * on to the cache.
+ */
+static void flush_hash_list_to_cache(struct hash_list *file_hash)
+{
+	FILE *cache;
+	int ret;
+	struct stat buf;
+
+	ret = stat(SDT_CACHE_DIR, &buf);
+	if (ret) {
+		ret = mkdir(SDT_CACHE_DIR, buf.st_mode);
+		if (ret) {
+			pr_err("%s : %s\n", SDT_CACHE_DIR, strerror(errno));
+			return;
+		}
+	}
+
+	cache = fopen(SDT_CACHE_DIR SDT_FILE_CACHE, "w");
+	if (!cache) {
+		pr_err("Error in creating %s file!\n",
+		       SDT_CACHE_DIR SDT_FILE_CACHE);
+		return;
+	}
+
+	file_hash_list__flush(file_hash, cache);
+	fclose(cache);
+}
+
+/**
+ * add_sdt_events: Add SDT events
+ * @arg: filename
+ *
+ * Initializes a hash table 'file_hash', calls add_to_hash_list() to add SDT
+ * events of @arg to the cache and then cleans them up.
+ * 'file_hash' list is a hash table which maintains all the information
+ * related to the files with the SDT events in them. The file name serves as the
+ * key to this hash list. Each entry of the file_hash table is a list head
+ * which contains a chain of 'file_list' entries. Each 'file_list' entry contains
+ * the list of SDT events found in that file. This hash serves as a mapping
+ * from file name to the SDT events. 'file_hash' is used to add/del SDT events
+ * to the SDT cache.
+ */
+int add_sdt_events(const char *arg)
+{
+	struct hash_list file_hash;
+	int ret;
+
+	if (!arg) {
+		pr_err("Error : File Name must be specified with \"--add\""
+		       "option!\n"
+	       "Usage :\n  perf sdt-cache --add <file-name>\n");
+		return -1;
+	}
+	/* Initialize the file hash_list */
+	file_hash_list__init(&file_hash);
+
+	/* Try to add the events to the file hash_list */

tools/perf/util/sdt.c new file +5 -0

+	default:
+		file_hash_list__cleanup(&file_hash);
+	}
+	return ret;
+}

tools/perf/util/sdt.h new file +0 -0

new file mode 100644
index 0000000..4ed27d7

tools/perf/util/sdt.h new file +24 -0

+
+#define DELIM ':'
+#define MAX_ADDR 17
+
+#define MOD 1
+#define NO_MOD 2
+
+struct file_sdt_ent {
+	char name[PATH_MAX];                    /* file name */
+	char sbuild_id[BUILD_ID_SIZE * 2 + 1];  /* Build id of the file */
+	struct list_head file_list;
+	struct list_head sdt_list;              /* SDT notes in this file */
+
+};
+
+/* hash table entry */
+struct hash_ent {
+	struct list_head list;
+};
+
+/* Hash table struct */
+struct hash_list {
+	struct hash_ent ent[HASH_TABLE_SIZE];
+};

Quoted 1 line · Hemant Kumar

This patch adds a new sub-command to perf : sdt-cache.

When I ran perf without option, sdt-cache did not appear. You should update command-list.txt and add Documentation/perf-sdt-cache.txt, so that sdt-cache is shown (Note that perf build automatically extracts NAME line and embeds it as a help message). Maybe commit ef12a141 is good to refer :)

Quoted 3 lines

sdt-cache command can be used to add, remove and dump SDT events. This patch adds support to only "add" the SDT events. The rest of the patches add support to rest of them.

You don't need to describe dump and remove in this patch. How about below?

perf-sdt-cache command manages SDT events in applications. This adds "perf sdt-cache --add <file>" to add SDT events in given file to local cache.

Quoted 12 lines

When user invokes "perf sdt-cache add <file-name>", two hash tables are
created: file_hash list and event_hash list. A typical entry in a file_hash table looks like:

             file hash      file_sdt_ent     file_sdt_ent
             |---------|   ---------------   -------------
             | list  ==|===|=>file_list =|===|=>file_list=|==..
key = 644 =>|         |   | sbuild_id   |   | sbuild_id  |
             |---------|   | name        |   | name       |
             |	      |   | sdt_list    |   | sdt_list   |
key = 645 =>| list    |   |   ||        |   |    ||      |
             |---------|   ---------------   --------------
	        ||            ||                 || Connected to SDT notes

Quoted 6 lines

---------------
| note_list |
sdt_note| name |
| provider |
-----||--------
connected to other SDT notes

Hmm, why don't you use hlist for file_hash.list?

Quoted 11 lines

Each entry of the file_hash table is a list which connects to file_list in file_sdt_ent. file_sdt_ent is allocated per file whenever a file is mapped to file_hash list. File name serves as the key to this hash table. If a file is added to this hash list, a file_sdt_ent is allocated and a list of SDT events in that file is created and assigned to sdt_list of file_sdt_ent.

Example usage :

# ./perf sdt-cache --add /home/user_app

Quoted 5 lines

4 events added for /home/user_app!

# ./perf sdt-cache --add /lib64/libc.so.6

8 events added for /usr/lib64/libc-2.16.so!

IMO, when succeeding to add events, it may not need the last "!", since it is eye-catching too much (as like as we get an error).

[...]

Quoted 52 lines

tools/perf/util/sdt.c new file +46 -0

new file mode 100644
index 0000000..0b56210
@@ -0,0 +1,665 @@
+/*
+ * util/sdt.c
+ * This contains the relevant functions needed to find the SDT events
+ * in a binary and adding them to a cache.
+ *
+ * TODOS:
+ * - Listing SDT events in most of the binaries present in the system.
+ * - Looking into directories provided by the user for binaries with SDTs,
+ * etc.
+ * - Support SDT event arguments.
+ * - Support SDT event semaphores.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "parse-events.h"
+#include "probe-event.h"
+#include "linux/list.h"
+#include "symbol.h"
+#include "build-id.h"
+
+struct file_info {
+	char *name;                             /* File name */
+	char sbuild_id[BUILD_ID_SIZE * 2 + 1];  /* Build id of the file */
+};
+
+/**
+ * get_hash_key: calculates the key to hash tables
+ * @str: input string
+ *
+ * adds the ascii values for all the chars in @str, multiplies with a prime
+ * and finds the modulo with HASH_TABLE_SIZE.
+ *
+ * Return : An integer key
+ */
+static unsigned get_hash_key(const char *str)
+{

tools/perf/util/sdt.c line 53

Quoted 7 lines

tools/perf/util/sdt.c new file +7 -0

+	unsigned value = 0, key;
+	unsigned c;
+
+	for (c = 0; str[c] != '\0'; c++)
+		value += str[c];
+
+	key = (value * 37) % HASH_TABLE_SIZE;

37 seems to a magic number :) how about defining it as HASH_PRIME_BASE?

Quoted 44 lines

tools/perf/util/sdt.c new file +44 -0

+
+	return key;
+}
+
+/**
+ * sdt_err: print SDT related error
+ * @val: error code
+ * @target: input file
+ *
+ * Display error corresponding to @val for file @target
+ */
+static int sdt_err(int val, const char *target)
+{
+	switch (-val) {
+	case 0:
+		break;
+	case ENOENT:
+		/* Absence of SDT markers */
+		pr_err("%s: No SDT events found\n", target);
+		break;
+	case EBADF:
+		pr_err("%s: Bad file name\n", target);
+		break;
+	default:
+		pr_err("%s\n", strerror(val));
+	}
+
+	return val;
+}
+
+/**
+ * cleanup_sdt_note_list : free the sdt notes' list
+ * @sdt_notes: sdt notes' list
+ *
+ * Free up the SDT notes in @sdt_notes.
+ */
+static void cleanup_sdt_note_list(struct list_head *sdt_notes)
+{
+	struct sdt_note *tmp, *pos;
+
+	if (list_empty(sdt_notes))
+		return;
+
+	list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {

tools/perf/util/sdt.c line 103

Quoted 6 lines

tools/perf/util/sdt.c new file +6 -0

+		list_del(&pos->note_list);
+		free(pos->name);
+		free(pos->provider);
+		free(pos);
+	}
+}

Hmm, since the list is created in tools/perf/util/symbol-elf.c, it is better to be defined in the same file, and same patch(1/1).

Quoted 26 lines

tools/perf/util/sdt.c new file +26 -0

+
+/**
+ * file_list_entry__init: Initialize a file_list_entry
+ * @fse: file_list_entry
+ * @file: file information
+ *
+ * Initializes @fse with the build id of a @file.
+ */
+static void file_list_entry__init(struct file_sdt_ent *fse,
+				 struct file_info *file)
+{
+	strcpy(fse->sbuild_id, file->sbuild_id);
+	INIT_LIST_HEAD(&fse->file_list);
+	INIT_LIST_HEAD(&fse->sdt_list);
+}
+
+/**
+ * sdt_events__get_count: Counts the number of sdt events
+ * @start: list_head to sdt_notes list
+ *
+ * Returns the number of SDT notes in a list
+ */
+static int sdt_events__get_count(struct list_head *start)
+{
+	struct sdt_note *sdt_ptr;
+	int count = 0;

tools/perf/util/sdt.c line 135

Quoted 6 lines

tools/perf/util/sdt.c new file +6 -0

+
+	list_for_each_entry(sdt_ptr, start, note_list) {
+		count++;
+	}
+	return count;
+}

This should be also in symbol-elf.c or symbol.h. Moreover, since there is no sdt_events data structure, the function name looks a bit odd.

Quoted 77 lines

tools/perf/util/sdt.c new file +76 -0

+
+/**
+ * file_hash_list__add: add an entry to file_hash_list
+ * @sdt_notes: list of sdt_notes
+ * @file: file name and build id
+ * @file_hash: hash table for file and sdt notes
+ *
+ * Get the key corresponding to @file->name. Fetch the entry
+ * for that key. Build a file_list_entry fse, assign the SDT notes
+ * to it and then assign fse to the fetched entry into the hash.
+ */
+static int file_hash_list__add(struct list_head *sdt_notes,
+				struct file_info *file,
+				struct hash_list *file_hash)
+{
+	struct file_sdt_ent *fse;
+	struct list_head *ent_head;
+	int key, nr_evs;
+
+	key = get_hash_key(file->name);
+	ent_head = &file_hash->ent[key].list;
+
+	/* Initialize the file entry */
+	fse = (struct file_sdt_ent *)malloc(sizeof(struct file_sdt_ent));
+	if (!fse)
+		return -ENOMEM;
+	file_list_entry__init(fse, file);
+	nr_evs = sdt_events__get_count(sdt_notes);
+	list_splice(sdt_notes, &fse->sdt_list);
+
+	printf("%d events added for %s\n", nr_evs, file->name);
+	strcpy(fse->name, file->name);
+
+	/* Add the file to the file hash entry */
+	list_add(&fse->file_list, ent_head);
+
+	return MOD;
+}
+
+/**
+ * file_hash_list__remove: Remove a file entry from the file_hash table
+ * @file_hash: file_hash_table
+ * @target: file name
+ *
+ * Removes the entries from file_hash table corresponding to @target.
+ * Gets the key from @target. Also frees up the SDT events for that
+ * file.
+ */
+static int file_hash_list__remove(struct hash_list *file_hash,
+				   const char *target)
+{
+	struct file_sdt_ent *fse, *tmp1;
+	struct list_head *sdt_head, *ent_head;
+	struct sdt_note *sdt_ptr, *tmp2;
+
+	char *res_path;
+	int key, nr_del = 0;
+
+	key = get_hash_key(target);
+	ent_head = &file_hash->ent[key].list;
+
+	res_path = realpath(target, NULL);
+	if (!res_path)
+		return -ENOMEM;
+
+	if (list_empty(ent_head))
+		return 0;
+
+	/* Got the file hash entry */
+	list_for_each_entry_safe(fse, tmp1, ent_head, file_list) {
+		sdt_head = &fse->sdt_list;
+		if (strcmp(res_path, fse->name))
+			continue;
+
+		/* Got the file list entry, now start removing */
+		list_for_each_entry_safe(sdt_ptr, tmp2, sdt_head, note_list) {

tools/perf/util/sdt.c line 217

Quoted 6 lines

tools/perf/util/sdt.c new file +6 -0

+			list_del(&sdt_ptr->note_list);
+			free(sdt_ptr->name);
+			free(sdt_ptr->provider);
+			free(sdt_ptr);
+			nr_del++;
+		}

You can use cleanup_sdt_note_list() here. If you need to count nr_del, modify cleanup_sdt_note_list() to return the number.

Quoted 45 lines

tools/perf/util/sdt.c new file +45 -0

+		list_del(&fse->file_list);
+		list_del(&fse->sdt_list);
+		free(fse);
+	}
+
+	return nr_del;
+}
+/**
+ * file_hash_list__entry_exists: Checks if a file is already present
+ * @file_hash: file_hash table
+ * @file: file name and build id to check
+ *
+ * Obtains the key from @file->name, fetches the correct entry,
+ * and goes through the chain to find out the correct file list entry.
+ * Compares the build id, if they match, return true, else, false.
+ */
+static bool file_hash_list__entry_exists(struct hash_list *file_hash,
+					  struct file_info *file)
+{
+	struct file_sdt_ent *fse;
+	struct list_head *ent_head;
+	int key;
+
+	key = get_hash_key(file->name);
+	ent_head = &file_hash->ent[key].list;
+	if (list_empty(ent_head))
+		return false;
+
+	list_for_each_entry(fse, ent_head, file_list) {
+		if (!strcmp(file->name, fse->name)) {
+			if (!strcmp(file->sbuild_id, fse->sbuild_id))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * copy_delim: copy till a character
+ * @src: source string
+ * @target: dest string
+ * @delim: till this character
+ * @len: length of @target
+ * @end: end of @src

tools/perf/util/sdt.c line 272

Quoted 10 lines

tools/perf/util/sdt.c new file +10 -0

+ *
+ * Returns the number of chars copied.
+ * NOTE: We need @end as @src may or may not be terminated by NULL
+ */
+static int copy_delim(char *src, char *target, char delim, size_t len,
+		      char *end)
+{
+	int i;
+
+	memset(target, '\0', len);

I'm not sure why this is needed.

tools/perf/util/sdt.c line 277

Quoted 5 lines

tools/perf/util/sdt.c new file +5 -0

+	for (i = 0; (src[i] != delim) && !(src + i > end) ; i++)
+		target[i] = src[i];
+
+	return i + 1;
+}

Anyway, this may be replaced with strchr(3) or strtok_r(3) and strncpy(3).

Quoted 10 lines

tools/perf/util/sdt.c new file +10 -0

+
+/**
+ * sdt_note__read: Parse SDT note info
+ * @ptr: raw data
+ * @sdt_list: empty list
+ * @end: end of the raw data
+ *
+ * Parse @ptr to find out SDT note name, provider, location and semaphore.
+ * All these data are separated by DELIM.
+ */

tools/perf/util/sdt.c line 294

Quoted 7 lines

tools/perf/util/sdt.c new file +7 -0

+static void sdt_note__read(char **ptr, struct list_head *sdt_list, char *end)
+{
+	struct sdt_note *sn;
+	char addr[MAX_ADDR];
+	int len = 0;
+
+	while (1) {

Hmm, shouldn't we check the end of the sdt note?

Quoted 55 lines

tools/perf/util/sdt.c new file +54 -0

+		sn = (struct sdt_note *)malloc(sizeof(struct sdt_note));
+		if (!sn)
+			return;
+		INIT_LIST_HEAD(&sn->note_list);
+		sn->name = (char *)malloc(PATH_MAX);
+		if (!sn->name)
+			return;
+		sn->provider = (char *)malloc(PATH_MAX);
+		if (!sn->provider)
+			return;
+		/* Extract the provider name */
+		len = copy_delim(*ptr, sn->provider, DELIM, PATH_MAX, end);
+		*ptr += len;
+
+		/* Extract the note name */
+		len = copy_delim(*ptr, sn->name, DELIM, PATH_MAX, end);
+		*ptr += len;
+
+		/* Extract the note's location */
+		len = copy_delim(*ptr, addr , DELIM, MAX_ADDR, end);
+		*ptr += len;
+		sscanf(addr, "%lx", &sn->addr.a64[0]);
+
+		/* Extract the sem location */
+		len = copy_delim(*ptr, addr , DELIM, MAX_ADDR, end);
+		*ptr += len;
+		sscanf(addr, "%lx", &sn->addr.a64[2]);
+		list_add(&sn->note_list, sdt_list);
+
+		/* If the entries for this file are finished */
+		if (**ptr == DELIM)
+			break;
+	}
+}
+
+/**
+ * file_hash_list__populate: Fill up the file hash table
+ * @file_hash: empty file hash table
+ * @data: raw cache data
+ * @size: size of data
+ *
+ * Find out the end of data with help of @size. Start parsing @data.
+ * In the outer loop, it reads the 'key' delimited by "::-". In the inner
+ * loop, it reads the file name, build id and calls sdt_note__read() to
+ * read the SDT notes. Multiple entries for the same key are delimited
+ * by "::". Then, it assigns the file name, build id and SDT notes to the
+ * list entry corresponding to 'key'.
+ */
+static void file_hash_list__populate(struct hash_list *file_hash, char *data,
+				     off_t size)
+{
+	struct list_head *ent_head;
+	struct file_sdt_ent *fse;
+	char *end, tmp[PATH_MAX], *ptr;

tools/perf/util/sdt.c line 355

Quoted 7 lines

tools/perf/util/sdt.c new file +7 -0

+	int key, len = 0;
+
+	end = data + size - 1;
+	ptr = data;
+	if (ptr == end)
+		return;
+	do {

Why don't you use while(ptr < end) {} here ?

Quoted 38 lines

tools/perf/util/sdt.c new file +38 -0

+		/* Obtain the key */
+		len = copy_delim(ptr, tmp, DELIM, PATH_MAX, end);
+		ptr += len;
+		key = atoi(tmp);
+		/* Obtain the file_hash list entry */
+		ent_head = &file_hash->ent[key].list;
+		while (1) {
+			fse = (struct file_sdt_ent *)
+				malloc(sizeof(struct file_sdt_ent));
+			if (!fse)
+				return;
+			INIT_LIST_HEAD(&fse->file_list);
+			INIT_LIST_HEAD(&fse->sdt_list);
+			/* Obtain the file name */
+			len = copy_delim(ptr, fse->name, DELIM,
+					 sizeof(fse->name), end);
+			ptr += len;
+			/* Obtain the build id */
+			len = copy_delim(ptr, fse->sbuild_id, DELIM,
+					 sizeof(fse->sbuild_id), end);
+			ptr += len;
+			sdt_note__read(&ptr, &fse->sdt_list, end);
+
+			list_add(&fse->file_list, ent_head);
+
+			/* Check for another file entry */
+			if ((*ptr++ == DELIM) && (*ptr == '-'))
+				break;
+		}
+		if (ptr == end)
+			break;
+		else
+			ptr++;
+
+	} while (1);
+}
+
+/**

tools/perf/util/sdt.c line 400

Quoted 7 lines

tools/perf/util/sdt.c new file +7 -0

+ * file_hash_list__init: Initializes the file hash list
+ * @file_hash: empty file_hash
+ *
+ * Opens the cache file, reads the data into 'data' and calls
+ * file_hash_list__populate() to populate the above hash list.
+ */
+static void file_hash_list__init(struct hash_list *file_hash)

This should return an error code, since there are lots of error paths.

Quoted 29 lines

tools/perf/util/sdt.c new file +29 -0

+{
+	struct stat sb;
+	char *data;
+	int fd, i, ret;
+
+	for (i = 0; i < HASH_TABLE_SIZE; i++)
+		INIT_LIST_HEAD(&file_hash->ent[i].list);
+
+	fd = open(SDT_CACHE_DIR SDT_FILE_CACHE, O_RDONLY);
+	if (fd == -1)
+		return;
+
+	ret = fstat(fd, &sb);
+	if (ret == -1) {
+		pr_err("fstat : error\n");
+		return;
+	}
+
+	if (!S_ISREG(sb.st_mode)) {
+		pr_err("%s is not a regular file\n", SDT_CACHE_DIR
+		       SDT_FILE_CACHE);
+		return;
+	}
+	/* Is size of the cache zero ?*/
+	if (!sb.st_size)
+		return;
+	/* Read the data */
+	data = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
+	if (data == MAP_FAILED) {

tools/perf/util/sdt.c line 436

Quoted 7 lines

tools/perf/util/sdt.c new file +7 -0

+		pr_err("Error in mmap\n");
+		return;
+	}
+
+	ret = madvise(data, sb.st_size, MADV_SEQUENTIAL);
+	if (ret == -1)
+		pr_debug("Error in madvise\n");

At first step, you don't need to take care of the speed.

Quoted 78 lines

tools/perf/util/sdt.c new file +78 -0

+	ret = close(fd);
+	if (ret == -1) {
+		pr_err("Error in close\n");
+		return;
+	}
+
+	/* Populate the hash list */
+	file_hash_list__populate(file_hash, data, sb.st_size);
+	ret = munmap(data, sb.st_size);
+	if (ret == -1)
+		pr_err("Error in munmap\n");
+}
+
+/**
+ * file_hash_list__cleanup: Free up all the space for file_hash list
+ * @file_hash: file_hash table
+ */
+static void file_hash_list__cleanup(struct hash_list *file_hash)
+{
+	struct file_sdt_ent *file_pos, *tmp;
+	struct list_head *ent_head, *sdt_head;
+	int i;
+
+	/* Go through all the entries */
+	for (i = 0; i < HASH_TABLE_SIZE; i++) {
+		ent_head = &file_hash->ent[i].list;
+		if (list_empty(ent_head))
+			continue;
+
+		list_for_each_entry_safe(file_pos, tmp, ent_head, file_list) {
+			sdt_head = &file_pos->sdt_list;
+			/* Cleanup the corresponding SDT notes' list */
+			cleanup_sdt_note_list(sdt_head);
+			list_del(&file_pos->file_list);
+			list_del(&file_pos->sdt_list);
+			free(file_pos);
+		}
+	}
+}
+
+/**
+ * add_to_hash_list: add an entry to file_hash_list
+ * @file_hash: file hash table
+ * @target: file name
+ *
+ * Does a sanity check for the @target, finds out its build id,
+ * checks if @target is already present in file hash list. If not present,
+ * delete any stale entries with this file name (i.e., entries matching this
+ * file name but having older build ids). And then, adds the file entry to
+ * file hash list and also updates the SDT events in the event hash list.
+ */
+static int add_to_hash_list(struct hash_list *file_hash, const char *target)
+{
+	struct file_info *file;
+	int ret = 0;
+	u8 build_id[BUILD_ID_SIZE];
+
+	LIST_HEAD(sdt_notes);
+
+	file = (struct file_info *)malloc(sizeof(struct file_info));
+	if (!file)
+		return -ENOMEM;
+
+	file->name = realpath(target, NULL);
+	if (!file->name) {
+		ret = -EBADF;
+		pr_err("%s: Bad file name!\n", target);
+		goto out;
+	}
+
+	symbol__elf_init();
+	if (filename__read_build_id(file->name, &build_id,
+				    sizeof(build_id)) < 0) {
+		pr_err("Couldn't read build-id in %s\n", file->name);
+		ret = -EBADF;
+		sdt_err(ret, file->name);
+		goto out;
+	}

tools/perf/util/sdt.c line 520

Quoted 6 lines

tools/perf/util/sdt.c new file +6 -0

+	build_id__sprintf(build_id, sizeof(build_id), file->sbuild_id);
+	/* File entry already exists ?*/
+	if (file_hash_list__entry_exists(file_hash, file)) {
+		pr_err("Error: SDT events for %s already exist!",
+		       file->name);
+		ret = NO_MOD;

NO_MOD is too generic. I'd like to suggest that this returns the number of modified(added) entries.

Quoted 51 lines

tools/perf/util/sdt.c new file +51 -0

+		goto out;
+	}
+
+	/*
+	 * This will also remove any stale entries (if any) from the event hash.
+	 * Stale entries will have the same file name but older build ids.
+	 */
+	file_hash_list__remove(file_hash, file->name);
+	ret = get_sdt_note_list(&sdt_notes, file->name);
+	if (!ret) {
+		/* Add the entry to file hash list */
+		ret = file_hash_list__add(&sdt_notes, file, file_hash);
+	} else {
+		sdt_err(ret, target);
+	}
+
+out:
+	free(file->name);
+	free(file);
+	return ret;
+}
+
+/**
+ * file_hash_list__flush: Flush the file_hash list to cache
+ * @file_hash: file_hash list
+ * @fcache: opened SDT events cache
+ *
+ * Iterate through all the entries of @file_hash and flush them
+ * onto fcache.
+ * The complete file hash list is flushed into the cache. First
+ * write the key for non-empty entry and then file entries for that
+ * key, and then the SDT notes. The delimiter used is ':'.
+ */
+static void file_hash_list__flush(struct hash_list *file_hash,
+				  FILE *fcache)
+{
+	struct file_sdt_ent *file_pos;
+	struct list_head *ent_head, *sdt_head;
+	struct sdt_note *sdt_ptr;
+	int i;
+
+	/* Go through all entries */
+	for (i = 0; i < HASH_TABLE_SIZE; i++) {
+		/* Obtain the list head */
+		ent_head = &file_hash->ent[i].list;
+		/* Empty ? */
+		if (list_empty(ent_head))
+			continue;
+		/* ':' are used here as delimiters */
+		fprintf(fcache, "%d:", i);
+		list_for_each_entry(file_pos, ent_head, file_list) {

tools/perf/util/sdt.c line 581

Quoted 10 lines

tools/perf/util/sdt.c new file +10 -0

+			fprintf(fcache, "%s:", file_pos->name);
+			fprintf(fcache, "%s:", file_pos->sbuild_id);
+			sdt_head = &file_pos->sdt_list;
+			list_for_each_entry(sdt_ptr, sdt_head, note_list) {
+				fprintf(fcache, "%s:%s:%lx:%lx:",
+					sdt_ptr->provider, sdt_ptr->name,
+					sdt_ptr->addr.a64[0],
+					sdt_ptr->addr.a64[2]);
+			}
+			fprintf(fcache, ":");

Hmm, this format is horrible. Please use more sscanf-readable format, so that we can simplify the reader-side code. e.g.

<number>:\n
<file>:<buildid>\n
<provider>:<name>:<addr>:<sem>\n
:\n
<number>:\n
...
Then, you can use fscanf(), or a combination of fgets() and sscanf(). We don't need to care about the loading speed at this point.

Quoted 69 lines

tools/perf/util/sdt.c new file +69 -0

+		}
+		/* '-' marks the end of entries for that key */
+		fprintf(fcache, "-");
+	}
+
+}
+
+/**
+ * flush_hash_list_to_cache: Flush everything from file_hash to disk
+ * @file_hash: file_hash list
+ *
+ * Opens a cache and calls file_hash_list__flush() to dump everything
+ * on to the cache.
+ */
+static void flush_hash_list_to_cache(struct hash_list *file_hash)
+{
+	FILE *cache;
+	int ret;
+	struct stat buf;
+
+	ret = stat(SDT_CACHE_DIR, &buf);
+	if (ret) {
+		ret = mkdir(SDT_CACHE_DIR, buf.st_mode);
+		if (ret) {
+			pr_err("%s : %s\n", SDT_CACHE_DIR, strerror(errno));
+			return;
+		}
+	}
+
+	cache = fopen(SDT_CACHE_DIR SDT_FILE_CACHE, "w");
+	if (!cache) {
+		pr_err("Error in creating %s file!\n",
+		       SDT_CACHE_DIR SDT_FILE_CACHE);
+		return;
+	}
+
+	file_hash_list__flush(file_hash, cache);
+	fclose(cache);
+}
+
+/**
+ * add_sdt_events: Add SDT events
+ * @arg: filename
+ *
+ * Initializes a hash table 'file_hash', calls add_to_hash_list() to add SDT
+ * events of @arg to the cache and then cleans them up.
+ * 'file_hash' list is a hash table which maintains all the information
+ * related to the files with the SDT events in them. The file name serves as the
+ * key to this hash list. Each entry of the file_hash table is a list head
+ * which contains a chain of 'file_list' entries. Each 'file_list' entry contains
+ * the list of SDT events found in that file. This hash serves as a mapping
+ * from file name to the SDT events. 'file_hash' is used to add/del SDT events
+ * to the SDT cache.
+ */
+int add_sdt_events(const char *arg)
+{
+	struct hash_list file_hash;
+	int ret;
+
+	if (!arg) {
+		pr_err("Error : File Name must be specified with \"--add\""
+		       "option!\n"
+	       "Usage :\n  perf sdt-cache --add <file-name>\n");
+		return -1;
+	}
+	/* Initialize the file hash_list */
+	file_hash_list__init(&file_hash);
+
+	/* Try to add the events to the file hash_list */

tools/perf/util/sdt.c line 660

Quoted 10 lines

tools/perf/util/sdt.c new file +10 -0

+	ret = add_to_hash_list(&file_hash, arg);
+	switch (ret) {
+	case MOD:
+		/* file hash table is dirty, flush it */
+		flush_hash_list_to_cache(&file_hash);
+	case NO_MOD:
+		/* file hash isn't dirty, do not flush */
+		file_hash_list__cleanup(&file_hash);
+		ret = 0;
+		break;

Again, MOD and NO_MOD is too general.

Quoted 10 lines

tools/perf/util/sdt.c new file +5 -0

+	default:
+		file_hash_list__cleanup(&file_hash);
+	}
+	return ret;
+}

tools/perf/util/sdt.h new file +0 -0

new file mode 100644
index 0000000..4ed27d7

tools/perf/util/sdt.h line 6

Quoted 7 lines

tools/perf/util/sdt.h new file +6 -0

@@ -0,0 +1,30 @@
+#include "build-id.h"
+
+#define HASH_TABLE_SIZE 2063
+#define SDT_CACHE_DIR "/var/cache/perf/"
+#define SDT_FILE_CACHE "perf-sdt-file.cache"
+#define SDT_EVENT_CACHE "perf-sdt-event.cache"

Hmm, this should be treated as same as buildid_dir. Please see util/config.c.

Thank you,

Quoted 18 lines

tools/perf/util/sdt.h new file +18 -0

+
+#define DELIM ':'
+#define MAX_ADDR 17
+
+#define MOD 1
+#define NO_MOD 2
+
+struct file_sdt_ent {
+	char name[PATH_MAX];                    /* file name */
+	char sbuild_id[BUILD_ID_SIZE * 2 + 1];  /* Build id of the file */
+	struct list_head file_list;
+	struct list_head sdt_list;              /* SDT notes in this file */
+
+};
+
+/* hash table entry */
+struct hash_ent {
+	struct list_head list;

tools/perf/util/sdt.h line 30

Quoted 8 lines

tools/perf/util/sdt.h new file +6 -0

+};
+
+/* Hash table struct */
+struct hash_list {
+	struct hash_ent ent[HASH_TABLE_SIZE];
+};

This patchset helps in listing dtrace style markers(SDT) present in user space applications through perf.
Notes/markers are placed at important places by the
developers. They have a negligible overhead when not enabled.
We can enable them and probe at these places and find some important information like the arguments' values, etc.

We have lots of applications which use SDT markers today, like:
Postgresql, MySql, Mozilla, Perl, Python, Java, Ruby, libvirt, QEMU, glib

To add SDT markers into user applications:
We need to have this header sys/sdt.h present.
sys/sdt.h used is version 3.
If not present, install systemtap-sdt-devel package (for fedora-20).

With this patchset,
- Use perf sdt-cache --add to add SDT events to a cache.

 # perf sdt-cache --add ./user_app

4 SDT events added for /home/user/user_app!

- Use perf sdt-cache --del to remove SDT events from the cache>

 # perf sdt-cache --del ./user_app

4 events removed for /home/user/user_app!

- Dump the cache onto stdout using perf sdt-cache --dump:

 # perf sdt-cache --dump
  /home/user/user_app :
  %user_app:foo_start
  %user_app:fun_start

- To probe and trace an SDT event :

  # perf record -e %user_app:foo_start -aR sleep 10

The support for perf to sdt events has undergone a lot of changes since it was introduced. After a lot of discussions (https://lkml.org/lkml/2014/7/20/284), the patchset is subdivided for ease of review.
Previously, a patchset supporting "perf list sdt" was posted, but it didn't make much sense since, only listing SDT events for an ELF won't help. This patchset aims at adding a sub-command "sdt-cache" to perf to manage a cache for management of the SDT events.

This link shows an example of marker probing with Systemtap:
https://sourceware.org/systemtap/wiki/AddingUserSpaceProbingToApps

This link provides important info regarding SDT notes:
http://sourceware.org/systemtap/wiki/UserSpaceProbeImplementation

- Markers in binaries :
These SDT markers are present in the ELF in the section named ".note.stapsdt".
Here, the name of the marker, its provider, type, location, base address, semaphore address.
We can retrieve these values using the members name_off and desc_off in Nhdr structure. If these are not enabled, they are present in the ELF as nop.

Changes since last series :
- Changed the entire (linked) list structure to hash lists to manage the SDT events.
- Added a sub command "sdt-cache" to perf to manage SDT events in the system.
- Added support to add and remove SDT events onto a cache.
- Added support to "perf record" to probe and record the SDT events.

TODO:
- Add support to add most of the SDT events on a system to the cache.
- Recognizing arguments and support to probe on them.

---

Hemant Kumar (5):
perf/sdt: ELF support for SDT
perf/sdt: Add SDT events into a cache perf/sdt: Show SDT cache contents
perf/sdt: Delete SDT events from cache perf/sdt: Add support to perf record to trace SDT events

 tools/perf/Makefile.perf       |    3 
 tools/perf/builtin-record.c    |   21 +
 tools/perf/builtin-sdt-cache.c |  108 +++++
 tools/perf/builtin.h           |    1 
 tools/perf/perf.c              |    1 
 tools/perf/util/parse-events.c |    7 
 tools/perf/util/parse-events.h |    7 
 tools/perf/util/probe-event.c  |  120 ++++-
 tools/perf/util/probe-event.h  |    8 
 tools/perf/util/probe-finder.c |    3 
 tools/perf/util/sdt.c          |  925 ++++++++++++++++++++++++++++++++++++++++
 tools/perf/util/sdt.h          |   30 +
 tools/perf/util/symbol-elf.c   |  207 +++++++++
 tools/perf/util/symbol.h       |   21 +
 14 files changed, 1440 insertions(+), 22 deletions(-)
 create mode 100644 tools/perf/builtin-sdt-cache.c
 create mode 100644 tools/perf/util/sdt.c
 create mode 100644 tools/perf/util/sdt.h

Hi,

Quoted 32 lines · Hemant Kumar

This patchset helps in listing dtrace style markers(SDT) present in user space applications through perf.
Notes/markers are placed at important places by the
developers. They have a negligible overhead when not enabled.
We can enable them and probe at these places and find some important information like the arguments' values, etc.

We have lots of applications which use SDT markers today, like:
Postgresql, MySql, Mozilla, Perl, Python, Java, Ruby, libvirt, QEMU, glib

To add SDT markers into user applications:
We need to have this header sys/sdt.h present.
sys/sdt.h used is version 3.
If not present, install systemtap-sdt-devel package (for fedora-20).

With this patchset,
- Use perf sdt-cache --add to add SDT events to a cache.

  # perf sdt-cache --add ./user_app

4 SDT events added for /home/user/user_app!

- Use perf sdt-cache --del to remove SDT events from the cache>

  # perf sdt-cache --del ./user_app

4 events removed for /home/user/user_app!

- Dump the cache onto stdout using perf sdt-cache --dump:

  # perf sdt-cache --dump
   /home/user/user_app :
   %user_app:foo_start
   %user_app:fun_start

Quoted 2 lines

- To probe and trace an SDT event :

   # perf record -e %user_app:foo_start -aR sleep 10

Looks great! :)

However, when I've tried to build, I got below errors..

CC util/sdt.o
util/sdt.c: In function ‘sdt_err’:
util/sdt.c:72:3: error: implicit declaration of function ‘pr_err’ [-Werror=implicit-function-declaration]

    pr_err("%s: No SDT events found\n", target);
    ^
util/sdt.c:72:3: error: nested extern declaration of ‘pr_err’ [-Werror=nested-externs]
util/sdt.c: In function ‘file_hash_list__init’:
util/sdt.c:489:3: error: implicit declaration of function ‘pr_debug’ [-Werror=implicit-function-declaration]
    pr_debug("Error in madvise\n");
    ^

util/sdt.c:489:3: error: nested extern declaration of ‘pr_debug’ [-Werror=nested-externs]
cc1: all warnings being treated as errors

Perhaps, you might working on the old tree. Could you update it?

[SNIP]