#ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static void update_function_graph_func(void);
+
+/* Both enabled by default (can be cleared by function_graph tracer flags */
+static bool fgraph_sleep_time = true;
+static bool fgraph_graph_time = true;
+
 #else
 static inline void update_function_graph_func(void) { }
 #endif
 
        calltime = trace->rettime - trace->calltime;
 
-       if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
+       if (!fgraph_graph_time) {
                int index;
 
                index = trace->depth;
        ASSIGN_OPS_HASH(graph_ops, &global_ops.local_hash)
 };
 
+void ftrace_graph_sleep_time_control(bool enable)
+{
+       fgraph_sleep_time = enable;
+}
+
+void ftrace_graph_graph_time_control(bool enable)
+{
+       fgraph_graph_time = enable;
+}
+
 int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
 {
        return 0;
         * Does the user want to count the time a function was asleep.
         * If so, do not update the time stamps.
         */
-       if (trace_flags & TRACE_ITER_SLEEP_TIME)
+       if (fgraph_sleep_time)
                return;
 
        timestamp = trace_clock_local();
 
 
 /* trace_flags holds trace_options default values */
 unsigned long trace_flags =
-       FUNCTION_DEFAULT_FLAGS | FUNCTION_GRAPH_DEFAULT_FLAGS |
+       FUNCTION_DEFAULT_FLAGS |
        TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
        TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO |
        TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |
 
 #define TRACE_GRAPH_PRINT_ABS_TIME      0x20
 #define TRACE_GRAPH_PRINT_IRQS          0x40
 #define TRACE_GRAPH_PRINT_TAIL          0x80
+#define TRACE_GRAPH_SLEEP_TIME         0x100
+#define TRACE_GRAPH_GRAPH_TIME         0x200
 #define TRACE_GRAPH_PRINT_FILL_SHIFT   28
 #define TRACE_GRAPH_PRINT_FILL_MASK    (0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
 
+extern void ftrace_graph_sleep_time_control(bool enable);
+extern void ftrace_graph_graph_time_control(bool enable);
+
 extern enum print_line_t
 print_graph_function_flags(struct trace_iterator *iter, u32 flags);
 extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
  */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 # define FGRAPH_FLAGS                                          \
-               C(SLEEP_TIME,           "sleep-time"),          \
-               C(GRAPH_TIME,           "graph-time"),          \
                C(DISPLAY_GRAPH,        "display-graph"),
-/* Initially set for trace_flags */
-# define FUNCTION_GRAPH_DEFAULT_FLAGS \
-       (TRACE_ITER_SLEEP_TIME | TRACE_ITER_GRAPH_TIME)
 #else
 # define FGRAPH_FLAGS
-# define FUNCTION_GRAPH_DEFAULT_FLAGS  0UL
 #endif
 
 #ifdef CONFIG_BRANCH_TRACER
 
        { TRACER_OPT(funcgraph-irqs, TRACE_GRAPH_PRINT_IRQS) },
        /* Display function name after trailing } */
        { TRACER_OPT(funcgraph-tail, TRACE_GRAPH_PRINT_TAIL) },
+       /* Include sleep time (scheduled out) between entry and return */
+       { TRACER_OPT(sleep-time, TRACE_GRAPH_SLEEP_TIME) },
+       /* Include time within nested functions */
+       { TRACER_OPT(graph-time, TRACE_GRAPH_GRAPH_TIME) },
        { } /* Empty entry */
 };
 
 static struct tracer_flags tracer_flags = {
        /* Don't display overruns, proc, or tail by default */
        .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD |
-              TRACE_GRAPH_PRINT_DURATION | TRACE_GRAPH_PRINT_IRQS,
+              TRACE_GRAPH_PRINT_DURATION | TRACE_GRAPH_PRINT_IRQS |
+              TRACE_GRAPH_SLEEP_TIME | TRACE_GRAPH_GRAPH_TIME,
        .opts = trace_opts
 };
 
        if (bit == TRACE_GRAPH_PRINT_IRQS)
                ftrace_graph_skip_irqs = !set;
 
+       if (bit == TRACE_GRAPH_SLEEP_TIME)
+               ftrace_graph_sleep_time_control(set);
+
+       if (bit == TRACE_GRAPH_GRAPH_TIME)
+               ftrace_graph_graph_time_control(set);
+
        return 0;
 }