4 * Copyright (C) 2008 James Smart, Emulex Corporation
5 * Copyright (C) 2011 Red Hat, Inc. All rights reserved.
6 * Copyright (C) 2011 Mike Christie
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/slab.h>
24 #include <linux/blk-mq.h>
25 #include <linux/delay.h>
26 #include <linux/scatterlist.h>
27 #include <linux/bsg-lib.h>
28 #include <linux/export.h>
29 #include <scsi/scsi_cmnd.h>
32 #define uptr64(val) ((void __user *)(uintptr_t)(val))
35 struct blk_mq_tag_set tag_set
;
37 bsg_timeout_fn
*timeout_fn
;
40 static int bsg_transport_check_proto(struct sg_io_v4
*hdr
)
42 if (hdr
->protocol
!= BSG_PROTOCOL_SCSI
||
43 hdr
->subprotocol
!= BSG_SUB_PROTOCOL_SCSI_TRANSPORT
)
45 if (!capable(CAP_SYS_RAWIO
))
50 static int bsg_transport_fill_hdr(struct request
*rq
, struct sg_io_v4
*hdr
,
53 struct bsg_job
*job
= blk_mq_rq_to_pdu(rq
);
55 job
->request_len
= hdr
->request_len
;
56 job
->request
= memdup_user(uptr64(hdr
->request
), hdr
->request_len
);
58 return PTR_ERR_OR_ZERO(job
->request
);
61 static int bsg_transport_complete_rq(struct request
*rq
, struct sg_io_v4
*hdr
)
63 struct bsg_job
*job
= blk_mq_rq_to_pdu(rq
);
67 * The assignments below don't make much sense, but are kept for
68 * bug by bug backwards compatibility:
70 hdr
->device_status
= job
->result
& 0xff;
71 hdr
->transport_status
= host_byte(job
->result
);
72 hdr
->driver_status
= driver_byte(job
->result
);
74 if (hdr
->device_status
|| hdr
->transport_status
|| hdr
->driver_status
)
75 hdr
->info
|= SG_INFO_CHECK
;
76 hdr
->response_len
= 0;
78 if (job
->result
< 0) {
79 /* we're only returning the result field in the reply */
80 job
->reply_len
= sizeof(u32
);
84 if (job
->reply_len
&& hdr
->response
) {
85 int len
= min(hdr
->max_response_len
, job
->reply_len
);
87 if (copy_to_user(uptr64(hdr
->response
), job
->reply
, len
))
90 hdr
->response_len
= len
;
93 /* we assume all request payload was transferred, residual == 0 */
97 unsigned int rsp_len
= job
->reply_payload
.payload_len
;
99 if (WARN_ON(job
->reply_payload_rcv_len
> rsp_len
))
102 hdr
->din_resid
= rsp_len
- job
->reply_payload_rcv_len
;
110 static void bsg_transport_free_rq(struct request
*rq
)
112 struct bsg_job
*job
= blk_mq_rq_to_pdu(rq
);
117 static const struct bsg_ops bsg_transport_ops
= {
118 .check_proto
= bsg_transport_check_proto
,
119 .fill_hdr
= bsg_transport_fill_hdr
,
120 .complete_rq
= bsg_transport_complete_rq
,
121 .free_rq
= bsg_transport_free_rq
,
125 * bsg_teardown_job - routine to teardown a bsg job
126 * @kref: kref inside bsg_job that is to be torn down
128 static void bsg_teardown_job(struct kref
*kref
)
130 struct bsg_job
*job
= container_of(kref
, struct bsg_job
, kref
);
131 struct request
*rq
= blk_mq_rq_from_pdu(job
);
133 put_device(job
->dev
); /* release reference for the request */
135 kfree(job
->request_payload
.sg_list
);
136 kfree(job
->reply_payload
.sg_list
);
138 blk_mq_end_request(rq
, BLK_STS_OK
);
141 void bsg_job_put(struct bsg_job
*job
)
143 kref_put(&job
->kref
, bsg_teardown_job
);
145 EXPORT_SYMBOL_GPL(bsg_job_put
);
147 int bsg_job_get(struct bsg_job
*job
)
149 return kref_get_unless_zero(&job
->kref
);
151 EXPORT_SYMBOL_GPL(bsg_job_get
);
154 * bsg_job_done - completion routine for bsg requests
155 * @job: bsg_job that is complete
156 * @result: job reply result
157 * @reply_payload_rcv_len: length of payload recvd
159 * The LLD should call this when the bsg job has completed.
161 void bsg_job_done(struct bsg_job
*job
, int result
,
162 unsigned int reply_payload_rcv_len
)
164 job
->result
= result
;
165 job
->reply_payload_rcv_len
= reply_payload_rcv_len
;
166 blk_mq_complete_request(blk_mq_rq_from_pdu(job
));
168 EXPORT_SYMBOL_GPL(bsg_job_done
);
171 * bsg_complete - softirq done routine for destroying the bsg requests
172 * @rq: BSG request that holds the job to be destroyed
174 static void bsg_complete(struct request
*rq
)
176 struct bsg_job
*job
= blk_mq_rq_to_pdu(rq
);
181 static int bsg_map_buffer(struct bsg_buffer
*buf
, struct request
*req
)
183 size_t sz
= (sizeof(struct scatterlist
) * req
->nr_phys_segments
);
185 BUG_ON(!req
->nr_phys_segments
);
187 buf
->sg_list
= kzalloc(sz
, GFP_KERNEL
);
190 sg_init_table(buf
->sg_list
, req
->nr_phys_segments
);
191 buf
->sg_cnt
= blk_rq_map_sg(req
->q
, req
, buf
->sg_list
);
192 buf
->payload_len
= blk_rq_bytes(req
);
197 * bsg_prepare_job - create the bsg_job structure for the bsg request
198 * @dev: device that is being sent the bsg request
199 * @req: BSG request that needs a job structure
201 static bool bsg_prepare_job(struct device
*dev
, struct request
*req
)
203 struct request
*rsp
= req
->next_rq
;
204 struct bsg_job
*job
= blk_mq_rq_to_pdu(req
);
207 job
->timeout
= req
->timeout
;
210 ret
= bsg_map_buffer(&job
->request_payload
, req
);
212 goto failjob_rls_job
;
214 if (rsp
&& rsp
->bio
) {
215 ret
= bsg_map_buffer(&job
->reply_payload
, rsp
);
217 goto failjob_rls_rqst_payload
;
220 /* take a reference for the request */
221 get_device(job
->dev
);
222 kref_init(&job
->kref
);
225 failjob_rls_rqst_payload
:
226 kfree(job
->request_payload
.sg_list
);
228 job
->result
= -ENOMEM
;
233 * bsg_queue_rq - generic handler for bsg requests
234 * @hctx: hardware queue
237 * On error the create_bsg_job function should return a -Exyz error value
238 * that will be set to ->result.
240 * Drivers/subsys should pass this to the queue init function.
242 static blk_status_t
bsg_queue_rq(struct blk_mq_hw_ctx
*hctx
,
243 const struct blk_mq_queue_data
*bd
)
245 struct request_queue
*q
= hctx
->queue
;
246 struct device
*dev
= q
->queuedata
;
247 struct request
*req
= bd
->rq
;
248 struct bsg_set
*bset
=
249 container_of(q
->tag_set
, struct bsg_set
, tag_set
);
252 blk_mq_start_request(req
);
254 if (!get_device(dev
))
255 return BLK_STS_IOERR
;
257 if (!bsg_prepare_job(dev
, req
))
258 return BLK_STS_IOERR
;
260 ret
= bset
->job_fn(blk_mq_rq_to_pdu(req
));
262 return BLK_STS_IOERR
;
268 /* called right after the request is allocated for the request_queue */
269 static int bsg_init_rq(struct blk_mq_tag_set
*set
, struct request
*req
,
270 unsigned int hctx_idx
, unsigned int numa_node
)
272 struct bsg_job
*job
= blk_mq_rq_to_pdu(req
);
274 job
->reply
= kzalloc(SCSI_SENSE_BUFFERSIZE
, GFP_KERNEL
);
280 /* called right before the request is given to the request_queue user */
281 static void bsg_initialize_rq(struct request
*req
)
283 struct bsg_job
*job
= blk_mq_rq_to_pdu(req
);
284 void *reply
= job
->reply
;
286 memset(job
, 0, sizeof(*job
));
288 job
->reply_len
= SCSI_SENSE_BUFFERSIZE
;
289 job
->dd_data
= job
+ 1;
292 static void bsg_exit_rq(struct blk_mq_tag_set
*set
, struct request
*req
,
293 unsigned int hctx_idx
)
295 struct bsg_job
*job
= blk_mq_rq_to_pdu(req
);
300 void bsg_remove_queue(struct request_queue
*q
)
303 struct bsg_set
*bset
=
304 container_of(q
->tag_set
, struct bsg_set
, tag_set
);
306 bsg_unregister_queue(q
);
307 blk_cleanup_queue(q
);
308 blk_mq_free_tag_set(&bset
->tag_set
);
312 EXPORT_SYMBOL_GPL(bsg_remove_queue
);
314 static enum blk_eh_timer_return
bsg_timeout(struct request
*rq
, bool reserved
)
316 struct bsg_set
*bset
=
317 container_of(rq
->q
->tag_set
, struct bsg_set
, tag_set
);
319 if (!bset
->timeout_fn
)
321 return bset
->timeout_fn(rq
);
324 static const struct blk_mq_ops bsg_mq_ops
= {
325 .queue_rq
= bsg_queue_rq
,
326 .init_request
= bsg_init_rq
,
327 .exit_request
= bsg_exit_rq
,
328 .initialize_rq_fn
= bsg_initialize_rq
,
329 .complete
= bsg_complete
,
330 .timeout
= bsg_timeout
,
334 * bsg_setup_queue - Create and add the bsg hooks so we can receive requests
335 * @dev: device to attach bsg device to
336 * @name: device to give bsg device
337 * @job_fn: bsg job handler
338 * @dd_job_size: size of LLD data needed for each job
340 struct request_queue
*bsg_setup_queue(struct device
*dev
, const char *name
,
341 bsg_job_fn
*job_fn
, bsg_timeout_fn
*timeout
, int dd_job_size
)
343 struct bsg_set
*bset
;
344 struct blk_mq_tag_set
*set
;
345 struct request_queue
*q
;
348 bset
= kzalloc(sizeof(*bset
), GFP_KERNEL
);
350 return ERR_PTR(-ENOMEM
);
352 bset
->job_fn
= job_fn
;
353 bset
->timeout_fn
= timeout
;
355 set
= &bset
->tag_set
;
356 set
->ops
= &bsg_mq_ops
,
357 set
->nr_hw_queues
= 1;
358 set
->queue_depth
= 128;
359 set
->numa_node
= NUMA_NO_NODE
;
360 set
->cmd_size
= sizeof(struct bsg_job
) + dd_job_size
;
361 set
->flags
= BLK_MQ_F_NO_SCHED
| BLK_MQ_F_BLOCKING
;
362 if (blk_mq_alloc_tag_set(set
))
365 q
= blk_mq_init_queue(set
);
372 blk_queue_flag_set(QUEUE_FLAG_BIDI
, q
);
373 blk_queue_rq_timeout(q
, BLK_DEFAULT_SG_TIMEOUT
);
375 ret
= bsg_register_queue(q
, dev
, name
, &bsg_transport_ops
);
377 printk(KERN_ERR
"%s: bsg interface failed to "
378 "initialize - register queue\n", dev
->kobj
.name
);
379 goto out_cleanup_queue
;
384 blk_cleanup_queue(q
);
386 blk_mq_free_tag_set(set
);
391 EXPORT_SYMBOL_GPL(bsg_setup_queue
);