[PATCH 12/25] dynamic_debug: save non-matching queries to pending-list for later application.

[Jim Cromie <jim.cromie@gmail.com>]

When a query/rule doesnt match against current callsites, call
save_pending(new function) to copy the query off the stack, into
a (new) struct pending_query, and add to pending_queries (new) list.
Alter ddebug_change to return number of matches found for query/rule.

Patch adds: /sys/module/dynamic_debug/parameters/
  verbose - rw, added previously, here for completeness
  pending_ct - ro, shows current count of pending queries

With this and previous patches, queries submitted (on the boot-line
for example) which do not match (because module is not built-in,
and thus not present yet) are added to pending_queries.

Clear pending list in ddebug_remove_all_tables().  Note that latter is
currently only used for init-error path, its not called during cleanup.

Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
 lib/dynamic_debug.c |  108 +++++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 101 insertions(+), 7 deletions(-)

diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index 5774a6f..4135bf5 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -53,6 +53,16 @@ struct ddebug_query {
 	unsigned int first_lineno, last_lineno;
 };
 
+struct pending_query {
+	struct list_head link;
+	struct ddebug_query query;
+	char filename[100];
+	char module[30];
+	char function[50];
+	char format[200];
+	unsigned int flags, mask;
+};
+
 struct ddebug_iter {
 	struct ddebug_table *table;
 	unsigned int idx;
@@ -63,6 +73,11 @@ static LIST_HEAD(ddebug_tables);
 static int verbose = 0;
 module_param(verbose, int, 0644);
 
+/* legal but inapplicable queries, save and test against new modules */
+static LIST_HEAD(pending_queries);
+static int pending_ct;
+module_param(pending_ct, int, 0444);
+
 /* Return the last part of a pathname */
 static inline const char *basename(const char *path)
 {
@@ -111,14 +126,31 @@ static char *show_ddebug_query(const struct ddebug_query *q)
 	return p;
 }
 
+static char *show_pending_query(struct pending_query *pq)
+{
+	struct ddebug_query *q = &pq->query;
+
+	char *p = kasprintf(GFP_KERNEL,
+			"func=\"%s\" file=\"%s\" "
+			"module=\"%s\" format=\"%s\" lineno=%u-%u"
+			" flags=0x%x mask=0x%x",
+			q->function ? q->function : "",
+			q->filename ? q->filename : "",
+			q->module ? q->module : "",
+			q->format ? q->format : "",
+			q->first_lineno, q->last_lineno,
+			pq->flags, pq->mask);
+	return p;
+}
+
 /*
  * Search the tables for _ddebug's which match the given
  * `query' and apply the `flags' and `mask' to them.  Tells
  * the user which ddebug's were changed, or whether none
  * were matched.
  */
-static void ddebug_change(const struct ddebug_query *query,
-			   unsigned int flags, unsigned int mask)
+static int ddebug_change(const struct ddebug_query *query,
+			unsigned int flags, unsigned int mask)
 {
 	int i;
 	struct ddebug_table *dt;
@@ -181,8 +213,7 @@ static void ddebug_change(const struct ddebug_query *query,
 	}
 	mutex_unlock(&ddebug_lock);
 
-	if (!nfound)
-		pr_debug("no matches for query\n");
+	return nfound;
 }
 
 /*
@@ -421,13 +452,58 @@ static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
 	return 0;
 }
 
+/* copy query off stack, save flags & mask, and store in pending-list */
+static int ddebug_save_pending(struct ddebug_query *query,
+				unsigned int flags, unsigned int mask)
+{
+	struct pending_query *pq;
+	char *qstr;
+
+	qstr = show_ddebug_query(query);
+	pr_debug("add to pending: %s\n", qstr);
+	kfree(qstr);
+
+	pq = kzalloc(sizeof(struct pending_query), GFP_KERNEL);
+	if (pq == NULL)
+		return -ENOMEM;
+
+	/* copy non-null match-specs into allocd mem, update pointers */
+	if (query->module) {
+		strlcpy(pq->module, query->module, sizeof(pq->module));
+		pq->query.module = pq->module;
+	}
+	if (query->function) {
+		strlcpy(pq->function, query->function, sizeof(pq->function));
+		pq->query.function = pq->function;
+	}
+	if (query->filename) {
+		strlcpy(pq->filename, query->filename, sizeof(pq->filename));
+		pq->query.filename = pq->filename;
+	}
+	if (query->format) {
+		strlcpy(pq->format, query->format, sizeof(pq->format));
+		pq->query.format = pq->format;
+	}
+	pq->flags = flags;
+	pq->mask = mask;
+
+	mutex_lock(&ddebug_lock);
+	list_add(&pq->link, &pending_queries);
+	pending_ct++;
+	mutex_unlock(&ddebug_lock);
+
+	pr_debug("query saved as pending %d\n", pending_ct);
+	return 0;
+}
+
 static int ddebug_exec_query(char *query_string)
 {
 	unsigned int flags = 0, mask = 0;
 	struct ddebug_query query;
 #define MAXWORDS 9
 	int nwords;
-	char *words[MAXWORDS];
+	char *words[MAXWORDS], *qstr;
+	int nfound, rc = 0;
 
 	nwords = ddebug_tokenize(query_string, words, MAXWORDS);
 	if (nwords <= 0)
@@ -438,8 +514,17 @@ static int ddebug_exec_query(char *query_string)
 		return -EINVAL;
 
 	/* actually go and implement the change */
-	ddebug_change(&query, flags, mask);
-	return 0;
+	nfound = ddebug_change(&query, flags, mask);
+	qstr = show_ddebug_query(&query);
+	pr_debug("nfound %d on %s\n", nfound, qstr);
+	if (!nfound) {
+		if (flags & _DPRINTK_FLAGS_APPEND)
+			rc = ddebug_save_pending(&query, flags, mask);
+		else
+			pr_warn("no match on: %s\n", qstr);
+	}
+	kfree(qstr);
+	return rc;
 }
 
 /* handle multiple queries, continue on error, return last error */
@@ -845,6 +930,8 @@ EXPORT_SYMBOL_GPL(ddebug_remove_module);
 
 static void ddebug_remove_all_tables(void)
 {
+	struct pending_query *pq, *pqnext;
+
 	mutex_lock(&ddebug_lock);
 	while (!list_empty(&ddebug_tables)) {
 		struct ddebug_table *dt = list_entry(ddebug_tables.next,
@@ -852,6 +939,13 @@ static void ddebug_remove_all_tables(void)
 						      link);
 		ddebug_table_free(dt);
 	}
+	list_for_each_entry_safe(pq, pqnext, &pending_queries, link) {
+		char *qstr = show_pending_query(pq);
+		pr_debug("delete pending: %s\n", qstr);
+		kfree(qstr);
+		list_del_init(&pq->link);
+		kfree(pq);
+	}
 	mutex_unlock(&ddebug_lock);
 }
 
-- 
1.7.4.1