/*
         * 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
 {
        /*
         * 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.
         */
                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
  * @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)
 
        /*
         * 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);