UPSTREAM: selinux: Remove unnecessary check of array base in selinux_set_mapping()

[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / block / blk-core.c

diff --git a/block/blk-core.c b/block/blk-core.c
index d5745b5833c9d76527809c41b4718c3df70407df..6655083b23419b1fd5f095a8a3bab48884c768e2 100644 (file)
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -645,10 +645,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 +741,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);
@@ -2026,6 +2036,8 @@ static void blk_account_io_completion(struct request *req, unsigned int bytes)
                cpu = part_stat_lock();
                part = req->part;
                part_stat_add(cpu, part, sectors[rw], bytes >> 9);
+               if (req->cmd_flags & REQ_DISCARD)
+                       part_stat_add(cpu, part, discard_sectors, bytes >> 9);
                part_stat_unlock();
        }
 }
@@ -2050,10 +2062,17 @@ static void blk_account_io_done(struct request *req)
                part_stat_add(cpu, part, ticks[rw], duration);
                part_round_stats(cpu, part);
                part_dec_in_flight(part, rw);
+               if (req->cmd_flags & REQ_DISCARD)
+                       part_stat_inc(cpu, part, discard_ios);
+               if (!(req->cmd_flags & REQ_STARTED))
+                       part_stat_inc(cpu, part, flush_ios);
 
                hd_struct_put(part);
                part_stat_unlock();
        }
+
+       if (req->cmd_flags & REQ_FLUSH_SEQ)
+               req->q->flush_ios++;
 }
 
 #ifdef CONFIG_PM_RUNTIME
@@ -2198,6 +2217,8 @@ void blk_dequeue_request(struct request *rq)
         * the driver side.
         */
        if (blk_account_rq(rq)) {
+               if (!queue_in_flight(q))
+                       q->in_flight_stamp = ktime_get();
                q->in_flight[rq_is_sync(rq)]++;
                set_io_start_time_ns(rq);
        }
@@ -2229,6 +2250,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 +2310,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
@@ -3086,6 +3108,9 @@ int blk_pre_runtime_suspend(struct request_queue *q)
 {
        int ret = 0;
 
+       if (!q->dev)
+               return ret;
+
        spin_lock_irq(q->queue_lock);
        if (q->nr_pending) {
                ret = -EBUSY;
@@ -3113,6 +3138,9 @@ EXPORT_SYMBOL(blk_pre_runtime_suspend);
  */
 void blk_post_runtime_suspend(struct request_queue *q, int err)
 {
+       if (!q->dev)
+               return;
+
        spin_lock_irq(q->queue_lock);
        if (!err) {
                q->rpm_status = RPM_SUSPENDED;
@@ -3137,6 +3165,9 @@ EXPORT_SYMBOL(blk_post_runtime_suspend);
  */
 void blk_pre_runtime_resume(struct request_queue *q)
 {
+       if (!q->dev)
+               return;
+
        spin_lock_irq(q->queue_lock);
        q->rpm_status = RPM_RESUMING;
        spin_unlock_irq(q->queue_lock);
@@ -3159,6 +3190,9 @@ EXPORT_SYMBOL(blk_pre_runtime_resume);
  */
 void blk_post_runtime_resume(struct request_queue *q, int err)
 {
+       if (!q->dev)
+               return;
+
        spin_lock_irq(q->queue_lock);
        if (!err) {
                q->rpm_status = RPM_ACTIVE;
@@ -3180,7 +3214,8 @@ int __init blk_dev_init(void)
 
        /* used for unplugging and affects IO latency/throughput - HIGHPRI */
        kblockd_workqueue = alloc_workqueue("kblockd",
-                                           WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
+                                           WQ_MEM_RECLAIM | WQ_HIGHPRI |
+                                           WQ_POWER_EFFICIENT, 0);
        if (!kblockd_workqueue)
                panic("Failed to create kblockd\n");