static struct tracer_opt blk_tracer_opts[] = {
        /* Default disable the minimalistic output */
-       { TRACER_OPT(blk_classic, TRACE_BLK_OPT_CLASSIC ) },
+       { TRACER_OPT(blk_classic, TRACE_BLK_OPT_CLASSIC) },
        { }
 };
 
        pid_t pid;
        int cpu, pc = 0;
 
-       if (unlikely(bt->trace_state != Blktrace_running || !blk_tracer_enabled))
+       if (unlikely(bt->trace_state != Blktrace_running ||
+                    !blk_tracer_enabled))
                return;
 
        what |= ddir_act[rw & WRITE];
                                                 sizeof(*t) + pdu_len, &flags);
                if (!event)
                        return;
-               
+
                ent = ring_buffer_event_data(event);
                t = (struct blk_io_trace *)ent;
                pc = preempt_count();
                if (blk_tr) {
                        ring_buffer_unlock_commit(blk_tr->buffer, event, flags);
                        if (pid != 0 &&
-                           (blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC) == 0 &&
+                           !(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC) &&
                            (trace_flags & TRACE_ITER_STACKTRACE) != 0)
                                __trace_stack(blk_tr, NULL, flags, 5, pc);
                        trace_wake_up();
 
 static void fill_rwbs(char *rwbs, const struct blk_io_trace *t)
 {
-        int i = 0;
+       int i = 0;
 
-        if (t->action & BLK_TC_DISCARD)           rwbs[i++] = 'D';
-        else if (t->action & BLK_TC_WRITE) rwbs[i++] = 'W';
-        else if (t->bytes)                rwbs[i++] = 'R';
-        else                              rwbs[i++] = 'N';
+       if (t->action & BLK_TC_DISCARD)
+               rwbs[i++] = 'D';
+       else if (t->action & BLK_TC_WRITE)
+               rwbs[i++] = 'W';
+       else if (t->bytes)
+               rwbs[i++] = 'R';
+       else
+               rwbs[i++] = 'N';
 
-        if (t->action & BLK_TC_AHEAD)     rwbs[i++] = 'A';
-        if (t->action & BLK_TC_BARRIER)           rwbs[i++] = 'B';
-        if (t->action & BLK_TC_SYNC)      rwbs[i++] = 'S';
-        if (t->action & BLK_TC_META)      rwbs[i++] = 'M';
+       if (t->action & BLK_TC_AHEAD)
+               rwbs[i++] = 'A';
+       if (t->action & BLK_TC_BARRIER)
+               rwbs[i++] = 'B';
+       if (t->action & BLK_TC_SYNC)
+               rwbs[i++] = 'S';
+       if (t->action & BLK_TC_META)
+               rwbs[i++] = 'M';
 
-        rwbs[i] = '\0';
+       rwbs[i] = '\0';
 }
 
 static inline
        return trace_seq_printf(s, "[%s]\n", cmd);
 }
 
-static int blk_log_with_error(struct trace_seq *s, const struct trace_entry *ent)
+static int blk_log_with_error(struct trace_seq *s,
+                             const struct trace_entry *ent)
 {
        if (t_sec(ent))
                return trace_seq_printf(s, "%llu + %u [%d]\n", t_sector(ent),
 
 #include <linux/kmod.h>
 #include <linux/ctype.h>
 #include <linux/genhd.h>
+#include <linux/blktrace_api.h>
 
 #include "check.h"
 
 }
 #endif
 
-#ifdef CONFIG_BLK_DEV_IO_TRACE
-extern struct attribute_group blk_trace_attr_group;
-#endif
-
 static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL);
 static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL);
 static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
 
 
 #ifdef __KERNEL__
 #if defined(CONFIG_BLK_DEV_IO_TRACE)
+
+#include <linux/sysfs.h>
+
 struct blk_trace {
        int trace_state;
        struct rchan *rchan;
 extern int blk_trace_startstop(struct request_queue *q, int start);
 extern int blk_trace_remove(struct request_queue *q);
 
+extern struct attribute_group blk_trace_attr_group;
+
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
 #define blk_trace_ioctl(bdev, cmd, arg)                (-ENOTTY)
 #define blk_trace_shutdown(q)                  do { } while (0)