ftrace: Have cached module filters be an active filter

When a module filter is added to set_ftrace_filter, if the module is not
loaded, it is cached. This should be considered an active filter, and
function tracing should be filtered by this. That is, if a cached module
filter is the only filter set, then no function tracing should be happening,
as all the functions available will be filtered out.

This makes sense, as the reason to add a cached module filter, is to trace
the module when you load it. There shouldn't be any other tracing happening
until then.

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>

diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 9fb9a67dc9d4f2dfe2360d55d90792af8e20399d..5857390ac35aa37d4d2431504adc98c3a3075026 100644 (file)
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -120,6 +120,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
  *            this ops will fail to register or set_filter_ip.
  * PID     - Is affected by set_ftrace_pid (allows filtering on those pids)
  * RCU     - Set when the ops can only be called when RCU is watching.
+ * TRACE_ARRAY - The ops->private points to a trace_array descriptor.
  */
 enum {
        FTRACE_OPS_FL_ENABLED                   = 1 << 0,
@@ -138,6 +139,7 @@ enum {
        FTRACE_OPS_FL_IPMODIFY                  = 1 << 13,
        FTRACE_OPS_FL_PID                       = 1 << 14,
        FTRACE_OPS_FL_RCU                       = 1 << 15,
+       FTRACE_OPS_FL_TRACE_ARRAY               = 1 << 16,
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index f1ccf8be9df77d6b8a7de996b874957f5f4bcebc..914539e3e301b1a371e8618062a220534dc2c11d 100644 (file)
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -1410,6 +1410,9 @@ alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
        if (!new_hash)
                return NULL;
 
+       if (hash)
+               new_hash->flags = hash->flags;
+
        /* Empty hash? */
        if (ftrace_hash_empty(hash))
                return new_hash;
@@ -1454,7 +1457,7 @@ __ftrace_hash_move(struct ftrace_hash *src)
        /*
         * If the new source is empty, just return the empty_hash.
         */
-       if (!src->count)
+       if (ftrace_hash_empty(src))
                return EMPTY_HASH;
 
        /*
@@ -1471,6 +1474,8 @@ __ftrace_hash_move(struct ftrace_hash *src)
        if (!new_hash)
                return NULL;
 
+       new_hash->flags = src->flags;
+
        size = 1 << src->size_bits;
        for (i = 0; i < size; i++) {
                hhd = &src->buckets[i];
@@ -1701,7 +1706,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
        struct dyn_ftrace *rec;
        bool update = false;
        int count = 0;
-       int all = 0;
+       int all = false;
 
        /* Only update if the ops has been registered */
        if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
@@ -1722,7 +1727,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
                hash = ops->func_hash->filter_hash;
                other_hash = ops->func_hash->notrace_hash;
                if (ftrace_hash_empty(hash))
-                       all = 1;
+                       all = true;
        } else {
                inc = !inc;
                hash = ops->func_hash->notrace_hash;
@@ -4028,6 +4033,9 @@ static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,
                free_ftrace_mod(ftrace_mod);
        }
 
+       if (enable && list_empty(head))
+               new_hash->flags &= ~FTRACE_HASH_FL_MOD;
+
        mutex_lock(&ftrace_lock);
 
        ret = ftrace_hash_move_and_update_ops(ops, orig_hash,
@@ -5035,9 +5043,11 @@ int ftrace_regex_release(struct inode *inode, struct file *file)
        if (file->f_mode & FMODE_WRITE) {
                filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
 
-               if (filter_hash)
+               if (filter_hash) {
                        orig_hash = &iter->ops->func_hash->filter_hash;
-               else
+                       if (!list_empty(&iter->tr->mod_trace))
+                               iter->hash->flags |= FTRACE_HASH_FL_MOD;
+               } else
                        orig_hash = &iter->ops->func_hash->notrace_hash;
 
                mutex_lock(&ftrace_lock);

diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index d63550cdbdfa5b34822be0d1dd5d7061d41ff988..13823951e42bd09fe42f8e1c3672074776cdb4eb 100644 (file)
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -773,10 +773,15 @@ struct ftrace_mod_load {
        int                      enable;
 };
 
+enum {
+       FTRACE_HASH_FL_MOD      = (1 << 0),
+};
+
 struct ftrace_hash {
        unsigned long           size_bits;
        struct hlist_head       *buckets;
        unsigned long           count;
+       unsigned long           flags;
        struct rcu_head         rcu;
 };
 
@@ -785,7 +790,7 @@ ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
 
 static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
 {
-       return !hash || !hash->count;
+       return !hash || !(hash->count || (hash->flags & FTRACE_HASH_FL_MOD));
 }
 
 /* Standard output formatting function used for function return traces */