Merge tag 'v3.10.84' into update

[GitHub/mt8127/android_kernel_alcatel_ttab.git] / block / blk-core.c

diff --git a/block/blk-core.c b/block/blk-core.c
index d5745b5833c9d76527809c41b4718c3df70407df..879b42ae344dcb0c36b2c144358ba00d0d6f1ddf 100644 (file)
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -45,6 +45,9 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(block_unplug);
 
 DEFINE_IDA(blk_queue_ida);
 
+int trap_non_toi_io;
+EXPORT_SYMBOL_GPL(trap_non_toi_io);
+
 /*
  * For the allocated request tables
  */
@@ -645,10 +648,12 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
        __set_bit(QUEUE_FLAG_BYPASS, &q->queue_flags);
 
        if (blkcg_init_queue(q))
-               goto fail_id;
+               goto fail_bdi;
 
        return q;
 
+fail_bdi:
+       bdi_destroy(&q->backing_dev_info);
 fail_id:
        ida_simple_remove(&blk_queue_ida, q->id);
 fail_q:
@@ -739,9 +744,17 @@ blk_init_allocated_queue(struct request_queue *q, request_fn_proc *rfn,
 
        q->sg_reserved_size = INT_MAX;
 
+       /* Protect q->elevator from elevator_change */
+       mutex_lock(&q->sysfs_lock);
+
        /* init elevator */
-       if (elevator_init(q, NULL))
+       if (elevator_init(q, NULL)) {
+               mutex_unlock(&q->sysfs_lock);
                return NULL;
+       }
+
+       mutex_unlock(&q->sysfs_lock);
+
        return q;
 }
 EXPORT_SYMBOL(blk_init_allocated_queue);
@@ -1850,6 +1863,9 @@ void submit_bio(int rw, struct bio *bio)
 {
        bio->bi_rw |= rw;
 
+       if (unlikely(trap_non_toi_io))
+               BUG_ON(!(bio->bi_flags & BIO_TOI));
+
        /*
         * If it's a regular read/write or a barrier with data attached,
         * go through the normal accounting stuff before submission.
@@ -1866,6 +1882,43 @@ void submit_bio(int rw, struct bio *bio)
                        count_vm_events(PGPGOUT, count);
                } else {
                        task_io_account_read(bio->bi_size);
+#if defined(FEATURE_STORAGE_PID_LOGGER)              
+                        {
+                           int i;
+                           struct bio_vec *bvec;
+
+                           //printk(KERN_INFO"submit_bio size:%d", bio->bi_size);
+                          bio_for_each_segment(bvec, bio, i)
+                           {
+                             struct page_pid_logger *tmp_logger;
+                             extern unsigned char *page_logger;
+                             extern spinlock_t g_locker;
+                             unsigned long flags;
+                             //printk(KERN_INFO"submit_bio bvec:%p size:%d", bvec, bio->bi_size);
+                             if( page_logger && bvec->bv_page) {
+                                unsigned long page_index;
+                        //#if defined(CONFIG_FLATMEM)
+                                //page_index = (unsigned long)((bvec->bv_page) - mem_map) ;
+                                //#else
+                                page_index = (unsigned long)(__page_to_pfn(bvec->bv_page))- PHYS_PFN_OFFSET;
+                                //#endif
+                                //printk(KERN_INFO"hank:submit_bio page_index:%lu", page_index);
+                                tmp_logger =((struct page_pid_logger *)page_logger) + page_index;
+                                spin_lock_irqsave(&g_locker, flags);
+                                if( page_index < num_physpages) {
+                                   if( tmp_logger->pid1 == 0XFFFF && tmp_logger->pid2 != current->pid)
+                                       tmp_logger->pid1 = current->pid;
+                                   else if( tmp_logger->pid1 != current->pid )
+                                       tmp_logger->pid2 = current->pid;
+                                }
+                                spin_unlock_irqrestore(&g_locker, flags);
+                                //printk(KERN_INFO"hank tmp logger pid1:%u pid2:%u pfn:%d \n", tmp_logger->pid1, tmp_logger->pid2, (unsigned long)((page) - mem_map) );
+                             }
+
+
+                           }
+                        }
+#endif
                        count_vm_events(PGPGIN, count);
                }
 
@@ -2229,6 +2282,7 @@ void blk_start_request(struct request *req)
        if (unlikely(blk_bidi_rq(req)))
                req->next_rq->resid_len = blk_rq_bytes(req->next_rq);
 
+       BUG_ON(test_bit(REQ_ATOM_COMPLETE, &req->atomic_flags));
        blk_add_timer(req);
 }
 EXPORT_SYMBOL(blk_start_request);
@@ -2288,7 +2342,7 @@ bool blk_update_request(struct request *req, int error, unsigned int nr_bytes)
        if (!req->bio)
                return false;
 
-       trace_block_rq_complete(req->q, req);
+       trace_block_rq_complete(req->q, req, nr_bytes);
 
        /*
         * For fs requests, rq is just carrier of independent bio's