block: add a separate operation type for secure erase

[linux-2.6-block.git] / kernel / trace / blktrace.c

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 9aef8654e90d12f954368e52d5d11b381ec9724f..af49caf973eb70d033b3c5ac4982fd91bcb88cfd 100644 (file)
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -189,6 +189,7 @@ static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),
                                 BLK_TC_ACT(BLK_TC_WRITE) };
 
 #define BLK_TC_RAHEAD          BLK_TC_AHEAD
+#define BLK_TC_PREFLUSH                BLK_TC_FLUSH
 
 /* The ilog2() calls fall out because they're constant */
 #define MASK_TC_BIT(rw, __name) ((rw & REQ_ ## __name) << \
@@ -199,7 +200,8 @@ static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),
  * blk_io_trace structure and places it in a per-cpu subbuffer.
  */
 static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
-                    int rw, u32 what, int error, int pdu_len, void *pdu_data)
+                    int op, int op_flags, u32 what, int error, int pdu_len,
+                    void *pdu_data)
 {
        struct task_struct *tsk = current;
        struct ring_buffer_event *event = NULL;
@@ -214,13 +216,16 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
        if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))
                return;
 
-       what |= ddir_act[rw & WRITE];
-       what |= MASK_TC_BIT(rw, SYNC);
-       what |= MASK_TC_BIT(rw, RAHEAD);
-       what |= MASK_TC_BIT(rw, META);
-       what |= MASK_TC_BIT(rw, DISCARD);
-       what |= MASK_TC_BIT(rw, FLUSH);
-       what |= MASK_TC_BIT(rw, FUA);
+       what |= ddir_act[op_is_write(op) ? WRITE : READ];
+       what |= MASK_TC_BIT(op_flags, SYNC);
+       what |= MASK_TC_BIT(op_flags, RAHEAD);
+       what |= MASK_TC_BIT(op_flags, META);
+       what |= MASK_TC_BIT(op_flags, PREFLUSH);
+       what |= MASK_TC_BIT(op_flags, FUA);
+       if (op == REQ_OP_DISCARD)
+               what |= BLK_TC_ACT(BLK_TC_DISCARD);
+       if (op == REQ_OP_FLUSH)
+               what |= BLK_TC_ACT(BLK_TC_FLUSH);
 
        pid = tsk->pid;
        if (act_log_check(bt, what, sector, pid))
@@ -708,11 +713,11 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
 
        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                what |= BLK_TC_ACT(BLK_TC_PC);
-               __blk_add_trace(bt, 0, nr_bytes, rq->cmd_flags,
+               __blk_add_trace(bt, 0, nr_bytes, req_op(rq), rq->cmd_flags,
                                what, rq->errors, rq->cmd_len, rq->cmd);
        } else  {
                what |= BLK_TC_ACT(BLK_TC_FS);
-               __blk_add_trace(bt, blk_rq_pos(rq), nr_bytes,
+               __blk_add_trace(bt, blk_rq_pos(rq), nr_bytes, req_op(rq),
                                rq->cmd_flags, what, rq->errors, 0, NULL);
        }
 }
@@ -770,7 +775,7 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
                return;
 
        __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-                       bio->bi_rw, what, error, 0, NULL);
+                       bio_op(bio), bio->bi_rw, what, error, 0, NULL);
 }
 
 static void blk_add_trace_bio_bounce(void *ignore,
@@ -818,7 +823,8 @@ static void blk_add_trace_getrq(void *ignore,
                struct blk_trace *bt = q->blk_trace;
 
                if (bt)
-                       __blk_add_trace(bt, 0, 0, rw, BLK_TA_GETRQ, 0, 0, NULL);
+                       __blk_add_trace(bt, 0, 0, rw, 0, BLK_TA_GETRQ, 0, 0,
+                                       NULL);
        }
 }
 
@@ -833,7 +839,7 @@ static void blk_add_trace_sleeprq(void *ignore,
                struct blk_trace *bt = q->blk_trace;
 
                if (bt)
-                       __blk_add_trace(bt, 0, 0, rw, BLK_TA_SLEEPRQ,
+                       __blk_add_trace(bt, 0, 0, rw, 0, BLK_TA_SLEEPRQ,
                                        0, 0, NULL);
        }
 }
@@ -843,7 +849,7 @@ static void blk_add_trace_plug(void *ignore, struct request_queue *q)
        struct blk_trace *bt = q->blk_trace;
 
        if (bt)
-               __blk_add_trace(bt, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL);
+               __blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL);
 }
 
 static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
@@ -860,7 +866,7 @@ static void blk_add_trace_unplug(void *ignore, struct request_queue *q,
                else
                        what = BLK_TA_UNPLUG_TIMER;
 
-               __blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);
+               __blk_add_trace(bt, 0, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);
        }
 }
 
@@ -874,8 +880,9 @@ static void blk_add_trace_split(void *ignore,
                __be64 rpdu = cpu_to_be64(pdu);
 
                __blk_add_trace(bt, bio->bi_iter.bi_sector,
-                               bio->bi_iter.bi_size, bio->bi_rw, BLK_TA_SPLIT,
-                               bio->bi_error, sizeof(rpdu), &rpdu);
+                               bio->bi_iter.bi_size, bio_op(bio), bio->bi_rw,
+                               BLK_TA_SPLIT, bio->bi_error, sizeof(rpdu),
+                               &rpdu);
        }
 }
 
@@ -907,7 +914,7 @@ static void blk_add_trace_bio_remap(void *ignore,
        r.sector_from = cpu_to_be64(from);
 
        __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-                       bio->bi_rw, BLK_TA_REMAP, bio->bi_error,
+                       bio_op(bio), bio->bi_rw, BLK_TA_REMAP, bio->bi_error,
                        sizeof(r), &r);
 }
 
@@ -940,7 +947,7 @@ static void blk_add_trace_rq_remap(void *ignore,
        r.sector_from = cpu_to_be64(from);
 
        __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq),
-                       rq_data_dir(rq), BLK_TA_REMAP, !!rq->errors,
+                       rq_data_dir(rq), 0, BLK_TA_REMAP, !!rq->errors,
                        sizeof(r), &r);
 }
 
@@ -965,10 +972,10 @@ void blk_add_driver_data(struct request_queue *q,
                return;
 
        if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
-               __blk_add_trace(bt, 0, blk_rq_bytes(rq), 0,
+               __blk_add_trace(bt, 0, blk_rq_bytes(rq), 0, 0,
                                BLK_TA_DRV_DATA, rq->errors, len, data);
        else
-               __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), 0,
+               __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), 0, 0,
                                BLK_TA_DRV_DATA, rq->errors, len, data);
 }
 EXPORT_SYMBOL_GPL(blk_add_driver_data);
@@ -1769,21 +1776,34 @@ void blk_dump_cmd(char *buf, struct request *rq)
        }
 }
 
-void blk_fill_rwbs(char *rwbs, u32 rw, int bytes)
+void blk_fill_rwbs(char *rwbs, int op, u32 rw, int bytes)
 {
        int i = 0;
 
-       if (rw & REQ_FLUSH)
+       if (rw & REQ_PREFLUSH)
                rwbs[i++] = 'F';
 
-       if (rw & WRITE)
+       switch (op) {
+       case REQ_OP_WRITE:
+       case REQ_OP_WRITE_SAME:
                rwbs[i++] = 'W';
-       else if (rw & REQ_DISCARD)
+               break;
+       case REQ_OP_DISCARD:
+               rwbs[i++] = 'D';
+               break;
+       case REQ_OP_SECURE_ERASE:
                rwbs[i++] = 'D';
-       else if (bytes)
+               rwbs[i++] = 'E';
+               break;
+       case REQ_OP_FLUSH:
+               rwbs[i++] = 'F';
+               break;
+       case REQ_OP_READ:
                rwbs[i++] = 'R';
-       else
+               break;
+       default:
                rwbs[i++] = 'N';
+       }
 
        if (rw & REQ_FUA)
                rwbs[i++] = 'F';
@@ -1793,8 +1813,6 @@ void blk_fill_rwbs(char *rwbs, u32 rw, int bytes)
                rwbs[i++] = 'S';
        if (rw & REQ_META)
                rwbs[i++] = 'M';
-       if (rw & REQ_SECURE)
-               rwbs[i++] = 'E';
 
        rwbs[i] = '\0';
 }