7 files changed, 172 insertions, 196 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 19fad003b19d..6a212b842d86 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -19,7 +19,6 @@ CFLAGS_REMOVE_mutex-debug.o = -pg
 CFLAGS_REMOVE_rtmutex-debug.o = -pg
 CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
-CFLAGS_REMOVE_sched.o = -pg
 endif
 
 obj-$(CONFIG_FREEZER) += freezer.o
@@ -90,7 +89,7 @@ obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
 
-ifneq ($(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER),y)
+ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
 # needed for x86 only.  Why this used to be enabled for all architectures is beyond
 # me.  I suspect most platforms don't need this, but until we know that for sure
diff --git a/kernel/sched.c b/kernel/sched.c
index 700aa9a1413f..3d1ee429219b 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -703,45 +703,18 @@ static __read_mostly char *sched_feat_names[] = {
 
 #undef SCHED_FEAT
 
-static int sched_feat_open(struct inode *inode, struct file *filp)
-{
-        filp->private_data = inode->i_private;
-        return 0;
-}
-
-static ssize_t
-sched_feat_read(struct file *filp, char __user *ubuf,
-                size_t cnt, loff_t *ppos)
+static int sched_feat_show(struct seq_file *m, void *v)
 {
-        char *buf;
-        int r = 0;
-        int len = 0;
         int i;
 
         for (i = 0; sched_feat_names[i]; i++) {
-                len += strlen(sched_feat_names[i]);
-                len += 4;
-        }
-
-        buf = kmalloc(len + 2, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-
-        for (i = 0; sched_feat_names[i]; i++) {
-                if (sysctl_sched_features & (1UL << i))
-                        r += sprintf(buf + r, "%s ", sched_feat_names[i]);
-                else
-                        r += sprintf(buf + r, "NO_%s ", sched_feat_names[i]);
+                if (!(sysctl_sched_features & (1UL << i)))
+                        seq_puts(m, "NO_");
+                seq_printf(m, "%s ", sched_feat_names[i]);
         }
+        seq_puts(m, "\n");
 
-        r += sprintf(buf + r, "\n");
-        WARN_ON(r >= len + 2);
-
-        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-
-        kfree(buf);
-
-        return r;
+        return 0;
 }
 
 static ssize_t
@@ -786,10 +759,17 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
+static int sched_feat_open(struct inode *inode, struct file *filp)
+{
+        return single_open(filp, sched_feat_show, NULL);
+}
+
 static struct file_operations sched_feat_fops = {
-        .open   = sched_feat_open,
-        .read   = sched_feat_read,
-        .write  = sched_feat_write,
+        .open           = sched_feat_open,
+        .write          = sched_feat_write,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
 };
 
 static __init int sched_init_debug(void)
@@ -1474,27 +1454,13 @@ static void
 update_group_shares_cpu(struct task_group *tg, int cpu,
                         unsigned long sd_shares, unsigned long sd_rq_weight)
 {
-        int boost = 0;
         unsigned long shares;
         unsigned long rq_weight;
 
         if (!tg->se[cpu])
                 return;
 
-        rq_weight = tg->cfs_rq[cpu]->load.weight;
-
-        /*
-         * If there are currently no tasks on the cpu pretend there is one of
-         * average load so that when a new task gets to run here it will not
-         * get delayed by group starvation.
-         */
-        if (!rq_weight) {
-                boost = 1;
-                rq_weight = NICE_0_LOAD;
-        }
-
-        if (unlikely(rq_weight > sd_rq_weight))
-                rq_weight = sd_rq_weight;
+        rq_weight = tg->cfs_rq[cpu]->rq_weight;
 
         /*
          *           \Sum shares * rq_weight
@@ -1502,7 +1468,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
          *               \Sum rq_weight
          *
          */
-        shares = (sd_shares * rq_weight) / (sd_rq_weight + 1);
+        shares = (sd_shares * rq_weight) / sd_rq_weight;
         shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
 
         if (abs(shares - tg->se[cpu]->load.weight) >
@@ -1511,11 +1477,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
                 unsigned long flags;
 
                 spin_lock_irqsave(&rq->lock, flags);
-                /*
-                 * record the actual number of shares, not the boosted amount.
-                 */
-                tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
-                tg->cfs_rq[cpu]->rq_weight = rq_weight;
+                tg->cfs_rq[cpu]->shares = shares;
 
                 __set_se_shares(tg->se[cpu], shares);
                 spin_unlock_irqrestore(&rq->lock, flags);
@@ -1529,13 +1491,23 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
  */
 static int tg_shares_up(struct task_group *tg, void *data)
 {
-        unsigned long rq_weight = 0;
+        unsigned long weight, rq_weight = 0;
         unsigned long shares = 0;
         struct sched_domain *sd = data;
         int i;
 
         for_each_cpu_mask(i, sd->span) {
-                rq_weight += tg->cfs_rq[i]->load.weight;
+                /*
+                 * If there are currently no tasks on the cpu pretend there
+                 * is one of average load so that when a new task gets to
+                 * run here it will not get delayed by group starvation.
+                 */
+                weight = tg->cfs_rq[i]->load.weight;
+                if (!weight)
+                        weight = NICE_0_LOAD;
+
+                tg->cfs_rq[i]->rq_weight = weight;
+                rq_weight += weight;
                 shares += tg->cfs_rq[i]->shares;
         }
 
@@ -1545,9 +1517,6 @@ static int tg_shares_up(struct task_group *tg, void *data)
         if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
                 shares = tg->shares;
 
-        if (!rq_weight)
-                rq_weight = cpus_weight(sd->span) * NICE_0_LOAD;
-
         for_each_cpu_mask(i, sd->span)
                 update_group_shares_cpu(tg, i, shares, rq_weight);
 
@@ -2838,7 +2807,7 @@ static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
         return ret;
 }
 
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
+static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
         __releases(busiest->lock)
 {
         spin_unlock(&busiest->lock);
@@ -6126,7 +6095,6 @@ static int __migrate_task_irq(struct task_struct *p, int src_cpu, int dest_cpu)
 
 /*
  * Figure out where task on dead CPU should go, use force if necessary.
- * NOTE: interrupts should be disabled by the caller
  */
 static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
 {
@@ -6636,28 +6604,6 @@ early_initcall(migration_init);
 
 #ifdef CONFIG_SCHED_DEBUG
 
-static inline const char *sd_level_to_string(enum sched_domain_level lvl)
-{
-        switch (lvl) {
-        case SD_LV_NONE:
-                        return "NONE";
-        case SD_LV_SIBLING:
-                        return "SIBLING";
-        case SD_LV_MC:
-                        return "MC";
-        case SD_LV_CPU:
-                        return "CPU";
-        case SD_LV_NODE:
-                        return "NODE";
-        case SD_LV_ALLNODES:
-                        return "ALLNODES";
-        case SD_LV_MAX:
-                        return "MAX";
-
-        }
-        return "MAX";
-}
-
 static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                                   cpumask_t *groupmask)
 {
@@ -6677,8 +6623,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 return -1;
         }
 
-        printk(KERN_CONT "span %s level %s\n",
-                str, sd_level_to_string(sd->level));
+        printk(KERN_CONT "span %s level %s\n", str, sd->name);
 
         if (!cpu_isset(cpu, sd->span)) {
                 printk(KERN_ERR "ERROR: domain->span does not contain "
@@ -7334,13 +7279,21 @@ struct allmasks {
 };
 
 #if     NR_CPUS > 128
-#define SCHED_CPUMASK_ALLOC             1
-#define SCHED_CPUMASK_FREE(v)           kfree(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks *v
+#define SCHED_CPUMASK_DECLARE(v)        struct allmasks *v
+static inline void sched_cpumask_alloc(struct allmasks **masks)
+{
+        *masks = kmalloc(sizeof(**masks), GFP_KERNEL);
+}
+static inline void sched_cpumask_free(struct allmasks *masks)
+{
+        kfree(masks);
+}
 #else
-#define SCHED_CPUMASK_ALLOC             0
-#define SCHED_CPUMASK_FREE(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks _v, *v = &_v
+#define SCHED_CPUMASK_DECLARE(v)        struct allmasks _v, *v = &_v
+static inline void sched_cpumask_alloc(struct allmasks **masks)
+{ }
+static inline void sched_cpumask_free(struct allmasks *masks)
+{ }
 #endif
 
 #define SCHED_CPUMASK_VAR(v, a)         cpumask_t *v = (cpumask_t *) \
@@ -7416,9 +7369,8 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 return -ENOMEM;
         }
 
-#if SCHED_CPUMASK_ALLOC
         /* get space for all scratch cpumask variables */
-        allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
+        sched_cpumask_alloc(&allmasks);
         if (!allmasks) {
                 printk(KERN_WARNING "Cannot alloc cpumask array\n");
                 kfree(rd);
@@ -7427,7 +7379,7 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 #endif
                 return -ENOMEM;
         }
-#endif
+
         tmpmask = (cpumask_t *)allmasks;
 
 
@@ -7681,13 +7633,13 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 cpu_attach_domain(sd, rd, i);
         }
 
-        SCHED_CPUMASK_FREE((void *)allmasks);
+        sched_cpumask_free(allmasks);
         return 0;
 
 #ifdef CONFIG_NUMA
 error:
         free_sched_groups(cpu_map, tmpmask);
-        SCHED_CPUMASK_FREE((void *)allmasks);
+        sched_cpumask_free(allmasks);
         kfree(rd);
         return -ENOMEM;
 #endif
@@ -7751,8 +7703,6 @@ static void detach_destroy_domains(const cpumask_t *cpu_map)
         cpumask_t tmpmask;
         int i;
 
-        unregister_sched_domain_sysctl();
-
         for_each_cpu_mask_nr(i, *cpu_map)
                 cpu_attach_domain(NULL, &def_root_domain, i);
         synchronize_sched();
@@ -7830,7 +7780,7 @@ match1:
                 ndoms_cur = 0;
                 doms_new = &fallback_doms;
                 cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
-                dattr_new = NULL;
+                WARN_ON_ONCE(dattr_new);
         }
 
         /* Build new domains */
@@ -8490,7 +8440,7 @@ static
 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
         struct cfs_rq *cfs_rq;
-        struct sched_entity *se, *parent_se;
+        struct sched_entity *se;
         struct rq *rq;
         int i;
 
@@ -8506,18 +8456,17 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
         for_each_possible_cpu(i) {
                 rq = cpu_rq(i);
 
-                cfs_rq = kmalloc_node(sizeof(struct cfs_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
+                                      GFP_KERNEL, cpu_to_node(i));
                 if (!cfs_rq)
                         goto err;
 
-                se = kmalloc_node(sizeof(struct sched_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                se = kzalloc_node(sizeof(struct sched_entity),
+                                  GFP_KERNEL, cpu_to_node(i));
                 if (!se)
                         goto err;
 
-                parent_se = parent ? parent->se[i] : NULL;
-                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent_se);
+                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
         }
 
         return 1;
@@ -8578,7 +8527,7 @@ static
 int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
 {
         struct rt_rq *rt_rq;
-        struct sched_rt_entity *rt_se, *parent_se;
+        struct sched_rt_entity *rt_se;
         struct rq *rq;
         int i;
 
@@ -8595,18 +8544,17 @@ int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
         for_each_possible_cpu(i) {
                 rq = cpu_rq(i);
 
-                rt_rq = kmalloc_node(sizeof(struct rt_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                rt_rq = kzalloc_node(sizeof(struct rt_rq),
+                                     GFP_KERNEL, cpu_to_node(i));
                 if (!rt_rq)
                         goto err;
 
-                rt_se = kmalloc_node(sizeof(struct sched_rt_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
+                                     GFP_KERNEL, cpu_to_node(i));
                 if (!rt_se)
                         goto err;
 
-                parent_se = parent ? parent->rt_se[i] : NULL;
-                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent_se);
+                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
         }
 
         return 1;
@@ -9249,11 +9197,12 @@ struct cgroup_subsys cpu_cgroup_subsys = {
  * (balbir@in.ibm.com).
  */
 
-/* track cpu usage of a group of tasks */
+/* track cpu usage of a group of tasks and its child groups */
 struct cpuacct {
         struct cgroup_subsys_state css;
         /* cpuusage holds pointer to a u64-type object on every cpu */
         u64 *cpuusage;
+        struct cpuacct *parent;
 };
 
 struct cgroup_subsys cpuacct_subsys;
@@ -9287,6 +9236,9 @@ static struct cgroup_subsys_state *cpuacct_create(
                 return ERR_PTR(-ENOMEM);
         }
 
+        if (cgrp->parent)
+                ca->parent = cgroup_ca(cgrp->parent);
+
         return &ca->css;
 }
 
@@ -9366,14 +9318,16 @@ static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
 static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
 {
         struct cpuacct *ca;
+        int cpu;
 
         if (!cpuacct_subsys.active)
                 return;
 
+        cpu = task_cpu(tsk);
         ca = task_ca(tsk);
-        if (ca) {
-                u64 *cpuusage = percpu_ptr(ca->cpuusage, task_cpu(tsk));
 
+        for (; ca; ca = ca->parent) {
+                u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
                 *cpuusage += cputime;
         }
 }
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 26ed8e3d1c15..baf2f17af462 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -53,6 +53,40 @@ static unsigned long nsec_low(unsigned long long nsec)
 
 #define SPLIT_NS(x) nsec_high(x), nsec_low(x)
 
+#ifdef CONFIG_FAIR_GROUP_SCHED
+static void print_cfs_group_stats(struct seq_file *m, int cpu,
+                struct task_group *tg)
+{
+        struct sched_entity *se = tg->se[cpu];
+        if (!se)
+                return;
+
+#define P(F) \
+        SEQ_printf(m, "  .%-30s: %lld\n", #F, (long long)F)
+#define PN(F) \
+        SEQ_printf(m, "  .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
+
+        PN(se->exec_start);
+        PN(se->vruntime);
+        PN(se->sum_exec_runtime);
+#ifdef CONFIG_SCHEDSTATS
+        PN(se->wait_start);
+        PN(se->sleep_start);
+        PN(se->block_start);
+        PN(se->sleep_max);
+        PN(se->block_max);
+        PN(se->exec_max);
+        PN(se->slice_max);
+        PN(se->wait_max);
+        PN(se->wait_sum);
+        P(se->wait_count);
+#endif
+        P(se->load.weight);
+#undef PN
+#undef P
+}
+#endif
+
 static void
 print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
 {
@@ -121,14 +155,9 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
         char path[128] = "";
-        struct cgroup *cgroup = NULL;
         struct task_group *tg = cfs_rq->tg;
 
-        if (tg)
-                cgroup = tg->css.cgroup;
-
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
 
         SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
 #else
@@ -168,6 +197,7 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 #ifdef CONFIG_SMP
         SEQ_printf(m, "  .%-30s: %lu\n", "shares", cfs_rq->shares);
 #endif
+        print_cfs_group_stats(m, cpu, cfs_rq->tg);
 #endif
 }
 
@@ -175,14 +205,9 @@ void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 {
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_RT_GROUP_SCHED)
         char path[128] = "";
-        struct cgroup *cgroup = NULL;
         struct task_group *tg = rt_rq->tg;
 
-        if (tg)
-                cgroup = tg->css.cgroup;
-
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
 
         SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, path);
 #else
@@ -272,7 +297,7 @@ static int sched_debug_show(struct seq_file *m, void *v)
         u64 now = ktime_to_ns(ktime_get());
         int cpu;
 
-        SEQ_printf(m, "Sched Debug Version: v0.07, %s %.*s\n",
+        SEQ_printf(m, "Sched Debug Version: v0.08, %s %.*s\n",
                 init_utsname()->release,
                 (int)strcspn(init_utsname()->version, " "),
                 init_utsname()->version);
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index d9ba9d5f99d6..2bdd44423599 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -537,13 +537,13 @@ static void update_curr_rt(struct rq *rq)
         for_each_sched_rt_entity(rt_se) {
                 rt_rq = rt_rq_of_se(rt_se);
 
-                spin_lock(&rt_rq->rt_runtime_lock);
                 if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
+                        spin_lock(&rt_rq->rt_runtime_lock);
                         rt_rq->rt_time += delta_exec;
                         if (sched_rt_runtime_exceeded(rt_rq))
                                 resched_task(curr);
+                        spin_unlock(&rt_rq->rt_runtime_lock);
                 }
-                spin_unlock(&rt_rq->rt_runtime_lock);
         }
 }
 
@@ -910,7 +910,8 @@ static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
 #define RT_MAX_TRIES 3
 
 static int double_lock_balance(struct rq *this_rq, struct rq *busiest);
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest);
+static inline void double_unlock_balance(struct rq *this_rq,
+                                                struct rq *busiest);
 
 static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep);
 
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index e60205722d0c..78db083390f0 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -326,96 +326,89 @@ ftrace_record_ip(unsigned long ip)
 
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec,
-                      unsigned char *old, unsigned char *new, int enable)
+                      unsigned char *nop, int enable)
 {
         unsigned long ip, fl;
+        unsigned char *call, *old, *new;
 
         ip = rec->ip;
 
-        if (ftrace_filtered && enable) {
+        /*
+         * If this record is not to be traced and
+         * it is not enabled then do nothing.
+         *
+         * If this record is not to be traced and
+         * it is enabled then disabled it.
+         *
+         */
+        if (rec->flags & FTRACE_FL_NOTRACE) {
+                if (rec->flags & FTRACE_FL_ENABLED)
+                        rec->flags &= ~FTRACE_FL_ENABLED;
+                else
+                        return 0;
+
+        } else if (ftrace_filtered && enable) {
                 /*
-                 * If filtering is on:
-                 *
-                 * If this record is set to be filtered and
-                 * is enabled then do nothing.
-                 *
-                 * If this record is set to be filtered and
-                 * it is not enabled, enable it.
-                 *
-                 * If this record is not set to be filtered
-                 * and it is not enabled do nothing.
-                 *
-                 * If this record is set not to trace then
-                 * do nothing.
-                 *
-                 * If this record is set not to trace and
-                 * it is enabled then disable it.
-                 *
-                 * If this record is not set to be filtered and
-                 * it is enabled, disable it.
+                 * Filtering is on:
                  */
 
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
-                                   FTRACE_FL_ENABLED);
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
 
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
-                    !fl || (fl == FTRACE_FL_NOTRACE))
+                /* Record is filtered and enabled, do nothing */
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
                         return 0;
 
-                /*
-                 * If it is enabled disable it,
-                 * otherwise enable it!
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
-                        /* swap new and old */
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* Record is not filtered and is not enabled do nothing */
+                if (!fl)
+                        return 0;
+
+                /* Record is not filtered but enabled, disable it */
+                if (fl == FTRACE_FL_ENABLED)
                         rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                else
+                /* Otherwise record is filtered but not enabled, enable it */
                         rec->flags |= FTRACE_FL_ENABLED;
-                }
         } else {
+                /* Disable or not filtered */
 
                 if (enable) {
-                        /*
-                         * If this record is set not to trace and is
-                         * not enabled, do nothing.
-                         */
-                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
-                        if (fl == FTRACE_FL_NOTRACE)
-                                return 0;
-
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
-                } else
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
-
-                if (enable) {
+                        /* if record is enabled, do nothing */
                         if (rec->flags & FTRACE_FL_ENABLED)
                                 return 0;
+
                         rec->flags |= FTRACE_FL_ENABLED;
+
                 } else {
+
+                        /* if record is not enabled do nothing */
                         if (!(rec->flags & FTRACE_FL_ENABLED))
                                 return 0;
+
                         rec->flags &= ~FTRACE_FL_ENABLED;
                 }
         }
 
+        call = ftrace_call_replace(ip, FTRACE_ADDR);
+
+        if (rec->flags & FTRACE_FL_ENABLED) {
+                old = nop;
+                new = call;
+        } else {
+                old = call;
+                new = nop;
+        }
+
         return ftrace_modify_code(ip, old, new);
 }
 
 static void ftrace_replace_code(int enable)
 {
         int i, failed;
-        unsigned char *new = NULL, *old = NULL;
+        unsigned char *nop = NULL;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
 
-        if (enable)
-                old = ftrace_nop_replace();
-        else
-                new = ftrace_nop_replace();
+        nop = ftrace_nop_replace();
 
         for (pg = ftrace_pages_start; pg; pg = pg->next) {
                 for (i = 0; i < pg->index; i++) {
@@ -433,7 +426,7 @@ static void ftrace_replace_code(int enable)
                                 unfreeze_record(rec);
                         }
 
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, nop, enable);
                         if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                 rec->flags |= FTRACE_FL_FAILED;
                                 if ((system_state == SYSTEM_BOOTING) ||
@@ -534,8 +527,7 @@ static void ftrace_startup(void)
 
         mutex_lock(&ftrace_start_lock);
         ftrace_start++;
-        if (ftrace_start == 1)
-                command |= FTRACE_ENABLE_CALLS;
+        command |= FTRACE_ENABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
                 saved_ftrace_func = ftrace_trace_function;
@@ -734,6 +726,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                     ((iter->flags & FTRACE_ITER_FAILURES) &&
                      !(rec->flags & FTRACE_FL_FAILED)) ||
 
+                    ((iter->flags & FTRACE_ITER_FILTER) &&
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
+
                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
                      !(rec->flags & FTRACE_FL_NOTRACE))) {
                         rec = NULL;
@@ -1186,7 +1181,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 
         mutex_lock(&ftrace_sysctl_lock);
         mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftrace_start && ftrace_enabled)
+        if (ftrace_start && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
         mutex_unlock(&ftrace_start_lock);
         mutex_unlock(&ftrace_sysctl_lock);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 036456cbb4f7..f780e9552f91 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -617,6 +617,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 list_del_init(&page->list);
                 free_buffer_page(page);
         }
+        mutex_unlock(&buffer->mutex);
         return -ENOMEM;
 }
 
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 697eda36b86a..d86e3252f300 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -1936,6 +1936,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         mutex_unlock(&trace_types_lock);
+        kfree(iter);
 
         return ERR_PTR(-ENOMEM);
 }