Merge tag 'asm-generic-mmu-context-5.11' of git://git.kernel.org/pub/scm/linux/kernel...

[linux-2.6-microblaze.git] / kernel / trace / ftrace.c

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 5414539..9c1bba8 100644 (file)
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -230,7 +230,7 @@ static void update_ftrace_function(void)
        /*
         * For static tracing, we need to be a bit more careful.
         * The function change takes affect immediately. Thus,
-        * we need to coorditate the setting of the function_trace_ops
+        * we need to coordinate the setting of the function_trace_ops
         * with the setting of the ftrace_trace_function.
         *
         * Set the function to the list ops, which will call the
@@ -1368,10 +1368,10 @@ static struct ftrace_hash *dup_hash(struct ftrace_hash *src, int size)
        int i;
 
        /*
-        * Make the hash size about 1/2 the # found
+        * Use around half the size (max bit of it), but
+        * a minimum of 2 is fine (as size of 0 or 1 both give 1 for bits).
         */
-       for (size /= 2; size; size >>= 1)
-               bits++;
+       bits = fls(size / 2);
 
        /* Don't allocate too much */
        if (bits > FTRACE_HASH_MAX_BITS)
@@ -1451,7 +1451,7 @@ static bool hash_contains_ip(unsigned long ip,
 {
        /*
         * The function record is a match if it exists in the filter
-        * hash and not in the notrace hash. Note, an emty hash is
+        * hash and not in the notrace hash. Note, an empty hash is
         * considered a match for the filter hash, but an empty
         * notrace hash is considered not in the notrace hash.
         */
@@ -1629,6 +1629,8 @@ static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)
 static struct ftrace_ops *
 ftrace_find_tramp_ops_any(struct dyn_ftrace *rec);
 static struct ftrace_ops *
+ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude);
+static struct ftrace_ops *
 ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *ops);
 
 static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
@@ -1778,7 +1780,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
                         * to it.
                         */
                        if (ftrace_rec_count(rec) == 1 &&
-                           ftrace_find_tramp_ops_any(rec))
+                           ftrace_find_tramp_ops_any_other(rec, ops))
                                rec->flags |= FTRACE_FL_TRAMP;
                        else
                                rec->flags &= ~FTRACE_FL_TRAMP;
@@ -2244,6 +2246,24 @@ ftrace_find_tramp_ops_any(struct dyn_ftrace *rec)
        return NULL;
 }
 
+static struct ftrace_ops *
+ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude)
+{
+       struct ftrace_ops *op;
+       unsigned long ip = rec->ip;
+
+       do_for_each_ftrace_op(op, ftrace_ops_list) {
+
+               if (op == op_exclude || !op->trampoline)
+                       continue;
+
+               if (hash_contains_ip(ip, op->func_hash))
+                       return op;
+       } while_for_each_ftrace_op(op);
+
+       return NULL;
+}
+
 static struct ftrace_ops *
 ftrace_find_tramp_ops_next(struct dyn_ftrace *rec,
                           struct ftrace_ops *op)
@@ -2402,7 +2422,7 @@ struct ftrace_ops direct_ops = {
  *
  * If the record has the FTRACE_FL_REGS set, that means that it
  * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS
- * is not not set, then it wants to convert to the normal callback.
+ * is not set, then it wants to convert to the normal callback.
  *
  * Returns the address of the trampoline to set to
  */
@@ -2976,7 +2996,7 @@ int ftrace_shutdown(struct ftrace_ops *ops, int command)
                synchronize_rcu_tasks_rude();
 
                /*
-                * When the kernel is preeptive, tasks can be preempted
+                * When the kernel is preemptive, tasks can be preempted
                 * while on a ftrace trampoline. Just scheduling a task on
                 * a CPU is not good enough to flush them. Calling
                 * synchornize_rcu_tasks() will wait for those tasks to
@@ -3129,18 +3149,20 @@ static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
 static int ftrace_allocate_records(struct ftrace_page *pg, int count)
 {
        int order;
+       int pages;
        int cnt;
 
        if (WARN_ON(!count))
                return -EINVAL;
 
-       order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
+       pages = DIV_ROUND_UP(count, ENTRIES_PER_PAGE);
+       order = get_count_order(pages);
 
        /*
         * We want to fill as much as possible. No more than a page
         * may be empty.
         */
-       while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
+       if (!is_power_of_2(pages))
                order--;
 
  again:
@@ -4368,7 +4390,7 @@ void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
  * @ip: The instruction pointer address to map @data to
  * @data: The data to map to @ip
  *
- * Returns 0 on succes otherwise an error.
+ * Returns 0 on success otherwise an error.
  */
 int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
                              unsigned long ip, void *data)
@@ -4536,7 +4558,7 @@ register_ftrace_function_probe(char *glob, struct trace_array *tr,
 
        /*
         * Note, there's a small window here that the func_hash->filter_hash
-        * may be NULL or empty. Need to be carefule when reading the loop.
+        * may be NULL or empty. Need to be careful when reading the loop.
         */
        mutex_lock(&probe->ops.func_hash->regex_lock);