Merge 4.13-rc7 into char-misc-next

We want the binder fix in here as well for testing and merge issues.

Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

5 files changed, 70 insertions, 38 deletions

diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index 9ebc2945f991..4f927a58dff8 100644
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -75,6 +75,8 @@ static const char *const blk_queue_flag_name[] = {
         QUEUE_FLAG_NAME(STATS),
         QUEUE_FLAG_NAME(POLL_STATS),
         QUEUE_FLAG_NAME(REGISTERED),
+        QUEUE_FLAG_NAME(SCSI_PASSTHROUGH),
+        QUEUE_FLAG_NAME(QUIESCED),
 };
 #undef QUEUE_FLAG_NAME
 
@@ -265,6 +267,7 @@ static const char *const cmd_flag_name[] = {
         CMD_FLAG_NAME(RAHEAD),
         CMD_FLAG_NAME(BACKGROUND),
         CMD_FLAG_NAME(NOUNMAP),
+        CMD_FLAG_NAME(NOWAIT),
 };
 #undef CMD_FLAG_NAME
 
diff --git a/block/blk-mq-pci.c b/block/blk-mq-pci.c
index 0c3354cf3552..76944e3271bf 100644
--- a/block/blk-mq-pci.c
+++ b/block/blk-mq-pci.c
@@ -36,12 +36,18 @@ int blk_mq_pci_map_queues(struct blk_mq_tag_set *set, struct pci_dev *pdev)
         for (queue = 0; queue < set->nr_hw_queues; queue++) {
                 mask = pci_irq_get_affinity(pdev, queue);
                 if (!mask)
-                        return -EINVAL;
+                        goto fallback;
 
                 for_each_cpu(cpu, mask)
                         set->mq_map[cpu] = queue;
         }
 
         return 0;
+
+fallback:
+        WARN_ON_ONCE(set->nr_hw_queues > 1);
+        for_each_possible_cpu(cpu)
+                set->mq_map[cpu] = 0;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(blk_mq_pci_map_queues);
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 535cbdf32aab..4603b115e234 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -360,12 +360,12 @@ struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
                 return ERR_PTR(ret);
 
         rq = blk_mq_get_request(q, NULL, op, &alloc_data);
+        blk_queue_exit(q);
 
         if (!rq)
                 return ERR_PTR(-EWOULDBLOCK);
 
         blk_mq_put_ctx(alloc_data.ctx);
-        blk_queue_exit(q);
 
         rq->__data_len = 0;
         rq->__sector = (sector_t) -1;
@@ -411,12 +411,11 @@ struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
         alloc_data.ctx = __blk_mq_get_ctx(q, cpu);
 
         rq = blk_mq_get_request(q, NULL, op, &alloc_data);
+        blk_queue_exit(q);
 
         if (!rq)
                 return ERR_PTR(-EWOULDBLOCK);
 
-        blk_queue_exit(q);
-
         return rq;
 }
 EXPORT_SYMBOL_GPL(blk_mq_alloc_request_hctx);
diff --git a/block/blk-throttle.c b/block/blk-throttle.c
index a7285bf2831c..80f5481fe9f6 100644
--- a/block/blk-throttle.c
+++ b/block/blk-throttle.c
@@ -382,6 +382,14 @@ static unsigned int tg_iops_limit(struct throtl_grp *tg, int rw)
         }                                                               \
 } while (0)
 
+static inline unsigned int throtl_bio_data_size(struct bio *bio)
+{
+        /* assume it's one sector */
+        if (unlikely(bio_op(bio) == REQ_OP_DISCARD))
+                return 512;
+        return bio->bi_iter.bi_size;
+}
+
 static void throtl_qnode_init(struct throtl_qnode *qn, struct throtl_grp *tg)
 {
         INIT_LIST_HEAD(&qn->node);
@@ -934,6 +942,7 @@ static bool tg_with_in_bps_limit(struct throtl_grp *tg, struct bio *bio,
         bool rw = bio_data_dir(bio);
         u64 bytes_allowed, extra_bytes, tmp;
         unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;
+        unsigned int bio_size = throtl_bio_data_size(bio);
 
         jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg->slice_start[rw];
 
@@ -947,14 +956,14 @@ static bool tg_with_in_bps_limit(struct throtl_grp *tg, struct bio *bio,
         do_div(tmp, HZ);
         bytes_allowed = tmp;
 
-        if (tg->bytes_disp[rw] + bio->bi_iter.bi_size <= bytes_allowed) {
+        if (tg->bytes_disp[rw] + bio_size <= bytes_allowed) {
                 if (wait)
                         *wait = 0;
                 return true;
         }
 
         /* Calc approx time to dispatch */
-        extra_bytes = tg->bytes_disp[rw] + bio->bi_iter.bi_size - bytes_allowed;
+        extra_bytes = tg->bytes_disp[rw] + bio_size - bytes_allowed;
         jiffy_wait = div64_u64(extra_bytes * HZ, tg_bps_limit(tg, rw));
 
         if (!jiffy_wait)
@@ -1034,11 +1043,12 @@ static bool tg_may_dispatch(struct throtl_grp *tg, struct bio *bio,
 static void throtl_charge_bio(struct throtl_grp *tg, struct bio *bio)
 {
         bool rw = bio_data_dir(bio);
+        unsigned int bio_size = throtl_bio_data_size(bio);
 
         /* Charge the bio to the group */
-        tg->bytes_disp[rw] += bio->bi_iter.bi_size;
+        tg->bytes_disp[rw] += bio_size;
         tg->io_disp[rw]++;
-        tg->last_bytes_disp[rw] += bio->bi_iter.bi_size;
+        tg->last_bytes_disp[rw] += bio_size;
         tg->last_io_disp[rw]++;
 
         /*
diff --git a/block/bsg-lib.c b/block/bsg-lib.c
index c4513b23f57a..dd56d7460cb9 100644
--- a/block/bsg-lib.c
+++ b/block/bsg-lib.c
@@ -29,26 +29,25 @@
 #include <scsi/scsi_cmnd.h>
 
 /**
- * bsg_destroy_job - routine to teardown/delete a bsg job
+ * bsg_teardown_job - routine to teardown a bsg job
  * @job: bsg_job that is to be torn down
  */
-static void bsg_destroy_job(struct kref *kref)
+static void bsg_teardown_job(struct kref *kref)
 {
         struct bsg_job *job = container_of(kref, struct bsg_job, kref);
         struct request *rq = job->req;
 
-        blk_end_request_all(rq, BLK_STS_OK);
-
         put_device(job->dev);   /* release reference for the request */
 
         kfree(job->request_payload.sg_list);
         kfree(job->reply_payload.sg_list);
-        kfree(job);
+
+        blk_end_request_all(rq, BLK_STS_OK);
 }
 
 void bsg_job_put(struct bsg_job *job)
 {
-        kref_put(&job->kref, bsg_destroy_job);
+        kref_put(&job->kref, bsg_teardown_job);
 }
 EXPORT_SYMBOL_GPL(bsg_job_put);
 
@@ -100,7 +99,7 @@ EXPORT_SYMBOL_GPL(bsg_job_done);
  */
 static void bsg_softirq_done(struct request *rq)
 {
-        struct bsg_job *job = rq->special;
+        struct bsg_job *job = blk_mq_rq_to_pdu(rq);
 
         bsg_job_put(job);
 }
@@ -122,33 +121,20 @@ static int bsg_map_buffer(struct bsg_buffer *buf, struct request *req)
 }
 
 /**
- * bsg_create_job - create the bsg_job structure for the bsg request
+ * bsg_prepare_job - create the bsg_job structure for the bsg request
  * @dev: device that is being sent the bsg request
  * @req: BSG request that needs a job structure
  */
-static int bsg_create_job(struct device *dev, struct request *req)
+static int bsg_prepare_job(struct device *dev, struct request *req)
 {
         struct request *rsp = req->next_rq;
-        struct request_queue *q = req->q;
         struct scsi_request *rq = scsi_req(req);
-        struct bsg_job *job;
+        struct bsg_job *job = blk_mq_rq_to_pdu(req);
         int ret;
 
-        BUG_ON(req->special);
-
-        job = kzalloc(sizeof(struct bsg_job) + q->bsg_job_size, GFP_KERNEL);
-        if (!job)
-                return -ENOMEM;
-
-        req->special = job;
-        job->req = req;
-        if (q->bsg_job_size)
-                job->dd_data = (void *)&job[1];
         job->request = rq->cmd;
         job->request_len = rq->cmd_len;
-        job->reply = rq->sense;
-        job->reply_len = SCSI_SENSE_BUFFERSIZE; /* Size of sense buffer
-                                                 * allocated */
+
         if (req->bio) {
                 ret = bsg_map_buffer(&job->request_payload, req);
                 if (ret)
@@ -187,7 +173,6 @@ static void bsg_request_fn(struct request_queue *q)
 {
         struct device *dev = q->queuedata;
         struct request *req;
-        struct bsg_job *job;
         int ret;
 
         if (!get_device(dev))
@@ -199,7 +184,7 @@ static void bsg_request_fn(struct request_queue *q)
                         break;
                 spin_unlock_irq(q->queue_lock);
 
-                ret = bsg_create_job(dev, req);
+                ret = bsg_prepare_job(dev, req);
                 if (ret) {
                         scsi_req(req)->result = ret;
                         blk_end_request_all(req, BLK_STS_OK);
@@ -207,8 +192,7 @@ static void bsg_request_fn(struct request_queue *q)
                         continue;
                 }
 
-                job = req->special;
-                ret = q->bsg_job_fn(job);
+                ret = q->bsg_job_fn(blk_mq_rq_to_pdu(req));
                 spin_lock_irq(q->queue_lock);
                 if (ret)
                         break;
@@ -219,6 +203,35 @@ static void bsg_request_fn(struct request_queue *q)
         spin_lock_irq(q->queue_lock);
 }
 
+static int bsg_init_rq(struct request_queue *q, struct request *req, gfp_t gfp)
+{
+        struct bsg_job *job = blk_mq_rq_to_pdu(req);
+        struct scsi_request *sreq = &job->sreq;
+
+        memset(job, 0, sizeof(*job));
+
+        scsi_req_init(sreq);
+        sreq->sense_len = SCSI_SENSE_BUFFERSIZE;
+        sreq->sense = kzalloc(sreq->sense_len, gfp);
+        if (!sreq->sense)
+                return -ENOMEM;
+
+        job->req = req;
+        job->reply = sreq->sense;
+        job->reply_len = sreq->sense_len;
+        job->dd_data = job + 1;
+
+        return 0;
+}
+
+static void bsg_exit_rq(struct request_queue *q, struct request *req)
+{
+        struct bsg_job *job = blk_mq_rq_to_pdu(req);
+        struct scsi_request *sreq = &job->sreq;
+
+        kfree(sreq->sense);
+}
+
 /**
  * bsg_setup_queue - Create and add the bsg hooks so we can receive requests
  * @dev: device to attach bsg device to
@@ -235,7 +248,9 @@ struct request_queue *bsg_setup_queue(struct device *dev, char *name,
         q = blk_alloc_queue(GFP_KERNEL);
         if (!q)
                 return ERR_PTR(-ENOMEM);
-        q->cmd_size = sizeof(struct scsi_request);
+        q->cmd_size = sizeof(struct bsg_job) + dd_job_size;
+        q->init_rq_fn = bsg_init_rq;
+        q->exit_rq_fn = bsg_exit_rq;
         q->request_fn = bsg_request_fn;
 
         ret = blk_init_allocated_queue(q);
@@ -243,7 +258,6 @@ struct request_queue *bsg_setup_queue(struct device *dev, char *name,
                 goto out_cleanup_queue;
 
         q->queuedata = dev;
-        q->bsg_job_size = dd_job_size;
         q->bsg_job_fn = job_fn;
         queue_flag_set_unlocked(QUEUE_FLAG_BIDI, q);
         queue_flag_set_unlocked(QUEUE_FLAG_SCSI_PASSTHROUGH, q);