source: src/linux/universal/linux-4.9/drivers/infiniband/ulp/srp/ib_srp.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 4 months ago

use new squashfs in all kernels

File size: 98.0 KB
Line 
1/*
2 * Copyright (c) 2005 Cisco Systems.  All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses.  You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 *     Redistribution and use in source and binary forms, with or
11 *     without modification, are permitted provided that the following
12 *     conditions are met:
13 *
14 *      - Redistributions of source code must retain the above
15 *        copyright notice, this list of conditions and the following
16 *        disclaimer.
17 *
18 *      - Redistributions in binary form must reproduce the above
19 *        copyright notice, this list of conditions and the following
20 *        disclaimer in the documentation and/or other materials
21 *        provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34
35#include <linux/module.h>
36#include <linux/init.h>
37#include <linux/slab.h>
38#include <linux/err.h>
39#include <linux/string.h>
40#include <linux/parser.h>
41#include <linux/random.h>
42#include <linux/jiffies.h>
43#include <rdma/ib_cache.h>
44
45#include <linux/atomic.h>
46
47#include <scsi/scsi.h>
48#include <scsi/scsi_device.h>
49#include <scsi/scsi_dbg.h>
50#include <scsi/scsi_tcq.h>
51#include <scsi/srp.h>
52#include <scsi/scsi_transport_srp.h>
53
54#include "ib_srp.h"
55
56#define DRV_NAME        "ib_srp"
57#define PFX             DRV_NAME ": "
58#define DRV_VERSION     "2.0"
59#define DRV_RELDATE     "July 26, 2015"
60
61MODULE_AUTHOR("Roland Dreier");
62MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator");
63MODULE_LICENSE("Dual BSD/GPL");
64MODULE_VERSION(DRV_VERSION);
65MODULE_INFO(release_date, DRV_RELDATE);
66
67static unsigned int srp_sg_tablesize;
68static unsigned int cmd_sg_entries;
69static unsigned int indirect_sg_entries;
70static bool allow_ext_sg;
71static bool prefer_fr = true;
72static bool register_always = true;
73static bool never_register;
74static int topspin_workarounds = 1;
75
76module_param(srp_sg_tablesize, uint, 0444);
77MODULE_PARM_DESC(srp_sg_tablesize, "Deprecated name for cmd_sg_entries");
78
79module_param(cmd_sg_entries, uint, 0444);
80MODULE_PARM_DESC(cmd_sg_entries,
81                 "Default number of gather/scatter entries in the SRP command (default is 12, max 255)");
82
83module_param(indirect_sg_entries, uint, 0444);
84MODULE_PARM_DESC(indirect_sg_entries,
85                 "Default max number of gather/scatter entries (default is 12, max is " __stringify(SG_MAX_SEGMENTS) ")");
86
87module_param(allow_ext_sg, bool, 0444);
88MODULE_PARM_DESC(allow_ext_sg,
89                  "Default behavior when there are more than cmd_sg_entries S/G entries after mapping; fails the request when false (default false)");
90
91module_param(topspin_workarounds, int, 0444);
92MODULE_PARM_DESC(topspin_workarounds,
93                 "Enable workarounds for Topspin/Cisco SRP target bugs if != 0");
94
95module_param(prefer_fr, bool, 0444);
96MODULE_PARM_DESC(prefer_fr,
97"Whether to use fast registration if both FMR and fast registration are supported");
98
99module_param(register_always, bool, 0444);
100MODULE_PARM_DESC(register_always,
101                 "Use memory registration even for contiguous memory regions");
102
103module_param(never_register, bool, 0444);
104MODULE_PARM_DESC(never_register, "Never register memory");
105
106static const struct kernel_param_ops srp_tmo_ops;
107
108static int srp_reconnect_delay = 10;
109module_param_cb(reconnect_delay, &srp_tmo_ops, &srp_reconnect_delay,
110                S_IRUGO | S_IWUSR);
111MODULE_PARM_DESC(reconnect_delay, "Time between successive reconnect attempts");
112
113static int srp_fast_io_fail_tmo = 15;
114module_param_cb(fast_io_fail_tmo, &srp_tmo_ops, &srp_fast_io_fail_tmo,
115                S_IRUGO | S_IWUSR);
116MODULE_PARM_DESC(fast_io_fail_tmo,
117                 "Number of seconds between the observation of a transport"
118                 " layer error and failing all I/O. \"off\" means that this"
119                 " functionality is disabled.");
120
121static int srp_dev_loss_tmo = 600;
122module_param_cb(dev_loss_tmo, &srp_tmo_ops, &srp_dev_loss_tmo,
123                S_IRUGO | S_IWUSR);
124MODULE_PARM_DESC(dev_loss_tmo,
125                 "Maximum number of seconds that the SRP transport should"
126                 " insulate transport layer errors. After this time has been"
127                 " exceeded the SCSI host is removed. Should be"
128                 " between 1 and " __stringify(SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
129                 " if fast_io_fail_tmo has not been set. \"off\" means that"
130                 " this functionality is disabled.");
131
132static unsigned ch_count;
133module_param(ch_count, uint, 0444);
134MODULE_PARM_DESC(ch_count,
135                 "Number of RDMA channels to use for communication with an SRP target. Using more than one channel improves performance if the HCA supports multiple completion vectors. The default value is the minimum of four times the number of online CPU sockets and the number of completion vectors supported by the HCA.");
136
137static void srp_add_one(struct ib_device *device);
138static void srp_remove_one(struct ib_device *device, void *client_data);
139static void srp_recv_done(struct ib_cq *cq, struct ib_wc *wc);
140static void srp_handle_qp_err(struct ib_cq *cq, struct ib_wc *wc,
141                const char *opname);
142static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event);
143
144static struct scsi_transport_template *ib_srp_transport_template;
145static struct workqueue_struct *srp_remove_wq;
146
147static struct ib_client srp_client = {
148        .name   = "srp",
149        .add    = srp_add_one,
150        .remove = srp_remove_one
151};
152
153static struct ib_sa_client srp_sa_client;
154
155static int srp_tmo_get(char *buffer, const struct kernel_param *kp)
156{
157        int tmo = *(int *)kp->arg;
158
159        if (tmo >= 0)
160                return sprintf(buffer, "%d", tmo);
161        else
162                return sprintf(buffer, "off");
163}
164
165static int srp_tmo_set(const char *val, const struct kernel_param *kp)
166{
167        int tmo, res;
168
169        res = srp_parse_tmo(&tmo, val);
170        if (res)
171                goto out;
172
173        if (kp->arg == &srp_reconnect_delay)
174                res = srp_tmo_valid(tmo, srp_fast_io_fail_tmo,
175                                    srp_dev_loss_tmo);
176        else if (kp->arg == &srp_fast_io_fail_tmo)
177                res = srp_tmo_valid(srp_reconnect_delay, tmo, srp_dev_loss_tmo);
178        else
179                res = srp_tmo_valid(srp_reconnect_delay, srp_fast_io_fail_tmo,
180                                    tmo);
181        if (res)
182                goto out;
183        *(int *)kp->arg = tmo;
184
185out:
186        return res;
187}
188
189static const struct kernel_param_ops srp_tmo_ops = {
190        .get = srp_tmo_get,
191        .set = srp_tmo_set,
192};
193
194static inline struct srp_target_port *host_to_target(struct Scsi_Host *host)
195{
196        return (struct srp_target_port *) host->hostdata;
197}
198
199static const char *srp_target_info(struct Scsi_Host *host)
200{
201        return host_to_target(host)->target_name;
202}
203
204static int srp_target_is_topspin(struct srp_target_port *target)
205{
206        static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad };
207        static const u8 cisco_oui[3]   = { 0x00, 0x1b, 0x0d };
208
209        return topspin_workarounds &&
210                (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) ||
211                 !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui));
212}
213
214static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size,
215                                   gfp_t gfp_mask,
216                                   enum dma_data_direction direction)
217{
218        struct srp_iu *iu;
219
220        iu = kmalloc(sizeof *iu, gfp_mask);
221        if (!iu)
222                goto out;
223
224        iu->buf = kzalloc(size, gfp_mask);
225        if (!iu->buf)
226                goto out_free_iu;
227
228        iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size,
229                                    direction);
230        if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
231                goto out_free_buf;
232
233        iu->size      = size;
234        iu->direction = direction;
235
236        return iu;
237
238out_free_buf:
239        kfree(iu->buf);
240out_free_iu:
241        kfree(iu);
242out:
243        return NULL;
244}
245
246static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
247{
248        if (!iu)
249                return;
250
251        ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
252                            iu->direction);
253        kfree(iu->buf);
254        kfree(iu);
255}
256
257static void srp_qp_event(struct ib_event *event, void *context)
258{
259        pr_debug("QP event %s (%d)\n",
260                 ib_event_msg(event->event), event->event);
261}
262
263static int srp_init_qp(struct srp_target_port *target,
264                       struct ib_qp *qp)
265{
266        struct ib_qp_attr *attr;
267        int ret;
268
269        attr = kmalloc(sizeof *attr, GFP_KERNEL);
270        if (!attr)
271                return -ENOMEM;
272
273        ret = ib_find_cached_pkey(target->srp_host->srp_dev->dev,
274                                  target->srp_host->port,
275                                  be16_to_cpu(target->pkey),
276                                  &attr->pkey_index);
277        if (ret)
278                goto out;
279
280        attr->qp_state        = IB_QPS_INIT;
281        attr->qp_access_flags = (IB_ACCESS_REMOTE_READ |
282                                    IB_ACCESS_REMOTE_WRITE);
283        attr->port_num        = target->srp_host->port;
284
285        ret = ib_modify_qp(qp, attr,
286                           IB_QP_STATE          |
287                           IB_QP_PKEY_INDEX     |
288                           IB_QP_ACCESS_FLAGS   |
289                           IB_QP_PORT);
290
291out:
292        kfree(attr);
293        return ret;
294}
295
296static int srp_new_cm_id(struct srp_rdma_ch *ch)
297{
298        struct srp_target_port *target = ch->target;
299        struct ib_cm_id *new_cm_id;
300
301        new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
302                                    srp_cm_handler, ch);
303        if (IS_ERR(new_cm_id))
304                return PTR_ERR(new_cm_id);
305
306        if (ch->cm_id)
307                ib_destroy_cm_id(ch->cm_id);
308        ch->cm_id = new_cm_id;
309        ch->path.sgid = target->sgid;
310        ch->path.dgid = target->orig_dgid;
311        ch->path.pkey = target->pkey;
312        ch->path.service_id = target->service_id;
313
314        return 0;
315}
316
317static struct ib_fmr_pool *srp_alloc_fmr_pool(struct srp_target_port *target)
318{
319        struct srp_device *dev = target->srp_host->srp_dev;
320        struct ib_fmr_pool_param fmr_param;
321
322        memset(&fmr_param, 0, sizeof(fmr_param));
323        fmr_param.pool_size         = target->mr_pool_size;
324        fmr_param.dirty_watermark   = fmr_param.pool_size / 4;
325        fmr_param.cache             = 1;
326        fmr_param.max_pages_per_fmr = dev->max_pages_per_mr;
327        fmr_param.page_shift        = ilog2(dev->mr_page_size);
328        fmr_param.access            = (IB_ACCESS_LOCAL_WRITE |
329                                       IB_ACCESS_REMOTE_WRITE |
330                                       IB_ACCESS_REMOTE_READ);
331
332        return ib_create_fmr_pool(dev->pd, &fmr_param);
333}
334
335/**
336 * srp_destroy_fr_pool() - free the resources owned by a pool
337 * @pool: Fast registration pool to be destroyed.
338 */
339static void srp_destroy_fr_pool(struct srp_fr_pool *pool)
340{
341        int i;
342        struct srp_fr_desc *d;
343
344        if (!pool)
345                return;
346
347        for (i = 0, d = &pool->desc[0]; i < pool->size; i++, d++) {
348                if (d->mr)
349                        ib_dereg_mr(d->mr);
350        }
351        kfree(pool);
352}
353
354/**
355 * srp_create_fr_pool() - allocate and initialize a pool for fast registration
356 * @device:            IB device to allocate fast registration descriptors for.
357 * @pd:                Protection domain associated with the FR descriptors.
358 * @pool_size:         Number of descriptors to allocate.
359 * @max_page_list_len: Maximum fast registration work request page list length.
360 */
361static struct srp_fr_pool *srp_create_fr_pool(struct ib_device *device,
362                                              struct ib_pd *pd, int pool_size,
363                                              int max_page_list_len)
364{
365        struct srp_fr_pool *pool;
366        struct srp_fr_desc *d;
367        struct ib_mr *mr;
368        int i, ret = -EINVAL;
369
370        if (pool_size <= 0)
371                goto err;
372        ret = -ENOMEM;
373        pool = kzalloc(sizeof(struct srp_fr_pool) +
374                       pool_size * sizeof(struct srp_fr_desc), GFP_KERNEL);
375        if (!pool)
376                goto err;
377        pool->size = pool_size;
378        pool->max_page_list_len = max_page_list_len;
379        spin_lock_init(&pool->lock);
380        INIT_LIST_HEAD(&pool->free_list);
381
382        for (i = 0, d = &pool->desc[0]; i < pool->size; i++, d++) {
383                mr = ib_alloc_mr(pd, IB_MR_TYPE_MEM_REG,
384                                 max_page_list_len);
385                if (IS_ERR(mr)) {
386                        ret = PTR_ERR(mr);
387                        goto destroy_pool;
388                }
389                d->mr = mr;
390                list_add_tail(&d->entry, &pool->free_list);
391        }
392
393out:
394        return pool;
395
396destroy_pool:
397        srp_destroy_fr_pool(pool);
398
399err:
400        pool = ERR_PTR(ret);
401        goto out;
402}
403
404/**
405 * srp_fr_pool_get() - obtain a descriptor suitable for fast registration
406 * @pool: Pool to obtain descriptor from.
407 */
408static struct srp_fr_desc *srp_fr_pool_get(struct srp_fr_pool *pool)
409{
410        struct srp_fr_desc *d = NULL;
411        unsigned long flags;
412
413        spin_lock_irqsave(&pool->lock, flags);
414        if (!list_empty(&pool->free_list)) {
415                d = list_first_entry(&pool->free_list, typeof(*d), entry);
416                list_del(&d->entry);
417        }
418        spin_unlock_irqrestore(&pool->lock, flags);
419
420        return d;
421}
422
423/**
424 * srp_fr_pool_put() - put an FR descriptor back in the free list
425 * @pool: Pool the descriptor was allocated from.
426 * @desc: Pointer to an array of fast registration descriptor pointers.
427 * @n:    Number of descriptors to put back.
428 *
429 * Note: The caller must already have queued an invalidation request for
430 * desc->mr->rkey before calling this function.
431 */
432static void srp_fr_pool_put(struct srp_fr_pool *pool, struct srp_fr_desc **desc,
433                            int n)
434{
435        unsigned long flags;
436        int i;
437
438        spin_lock_irqsave(&pool->lock, flags);
439        for (i = 0; i < n; i++)
440                list_add(&desc[i]->entry, &pool->free_list);
441        spin_unlock_irqrestore(&pool->lock, flags);
442}
443
444static struct srp_fr_pool *srp_alloc_fr_pool(struct srp_target_port *target)
445{
446        struct srp_device *dev = target->srp_host->srp_dev;
447
448        return srp_create_fr_pool(dev->dev, dev->pd, target->mr_pool_size,
449                                  dev->max_pages_per_mr);
450}
451
452/**
453 * srp_destroy_qp() - destroy an RDMA queue pair
454 * @qp: RDMA queue pair.
455 *
456 * Drain the qp before destroying it.  This avoids that the receive
457 * completion handler can access the queue pair while it is
458 * being destroyed.
459 */
460static void srp_destroy_qp(struct ib_qp *qp)
461{
462        ib_drain_rq(qp);
463        ib_destroy_qp(qp);
464}
465
466static int srp_create_ch_ib(struct srp_rdma_ch *ch)
467{
468        struct srp_target_port *target = ch->target;
469        struct srp_device *dev = target->srp_host->srp_dev;
470        struct ib_qp_init_attr *init_attr;
471        struct ib_cq *recv_cq, *send_cq;
472        struct ib_qp *qp;
473        struct ib_fmr_pool *fmr_pool = NULL;
474        struct srp_fr_pool *fr_pool = NULL;
475        const int m = 1 + dev->use_fast_reg * target->mr_per_cmd * 2;
476        int ret;
477
478        init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
479        if (!init_attr)
480                return -ENOMEM;
481
482        /* queue_size + 1 for ib_drain_rq() */
483        recv_cq = ib_alloc_cq(dev->dev, ch, target->queue_size + 1,
484                                ch->comp_vector, IB_POLL_SOFTIRQ);
485        if (IS_ERR(recv_cq)) {
486                ret = PTR_ERR(recv_cq);
487                goto err;
488        }
489
490        send_cq = ib_alloc_cq(dev->dev, ch, m * target->queue_size,
491                                ch->comp_vector, IB_POLL_DIRECT);
492        if (IS_ERR(send_cq)) {
493                ret = PTR_ERR(send_cq);
494                goto err_recv_cq;
495        }
496
497        init_attr->event_handler       = srp_qp_event;
498        init_attr->cap.max_send_wr     = m * target->queue_size;
499        init_attr->cap.max_recv_wr     = target->queue_size + 1;
500        init_attr->cap.max_recv_sge    = 1;
501        init_attr->cap.max_send_sge    = 1;
502        init_attr->sq_sig_type         = IB_SIGNAL_REQ_WR;
503        init_attr->qp_type             = IB_QPT_RC;
504        init_attr->send_cq             = send_cq;
505        init_attr->recv_cq             = recv_cq;
506
507        qp = ib_create_qp(dev->pd, init_attr);
508        if (IS_ERR(qp)) {
509                ret = PTR_ERR(qp);
510                goto err_send_cq;
511        }
512
513        ret = srp_init_qp(target, qp);
514        if (ret)
515                goto err_qp;
516
517        if (dev->use_fast_reg) {
518                fr_pool = srp_alloc_fr_pool(target);
519                if (IS_ERR(fr_pool)) {
520                        ret = PTR_ERR(fr_pool);
521                        shost_printk(KERN_WARNING, target->scsi_host, PFX
522                                     "FR pool allocation failed (%d)\n", ret);
523                        goto err_qp;
524                }
525        } else if (dev->use_fmr) {
526                fmr_pool = srp_alloc_fmr_pool(target);
527                if (IS_ERR(fmr_pool)) {
528                        ret = PTR_ERR(fmr_pool);
529                        shost_printk(KERN_WARNING, target->scsi_host, PFX
530                                     "FMR pool allocation failed (%d)\n", ret);
531                        goto err_qp;
532                }
533        }
534
535        if (ch->qp)
536                srp_destroy_qp(ch->qp);
537        if (ch->recv_cq)
538                ib_free_cq(ch->recv_cq);
539        if (ch->send_cq)
540                ib_free_cq(ch->send_cq);
541
542        ch->qp = qp;
543        ch->recv_cq = recv_cq;
544        ch->send_cq = send_cq;
545
546        if (dev->use_fast_reg) {
547                if (ch->fr_pool)
548                        srp_destroy_fr_pool(ch->fr_pool);
549                ch->fr_pool = fr_pool;
550        } else if (dev->use_fmr) {
551                if (ch->fmr_pool)
552                        ib_destroy_fmr_pool(ch->fmr_pool);
553                ch->fmr_pool = fmr_pool;
554        }
555
556        kfree(init_attr);
557        return 0;
558
559err_qp:
560        srp_destroy_qp(qp);
561
562err_send_cq:
563        ib_free_cq(send_cq);
564
565err_recv_cq:
566        ib_free_cq(recv_cq);
567
568err:
569        kfree(init_attr);
570        return ret;
571}
572
573/*
574 * Note: this function may be called without srp_alloc_iu_bufs() having been
575 * invoked. Hence the ch->[rt]x_ring checks.
576 */
577static void srp_free_ch_ib(struct srp_target_port *target,
578                           struct srp_rdma_ch *ch)
579{
580        struct srp_device *dev = target->srp_host->srp_dev;
581        int i;
582
583        if (!ch->target)
584                return;
585
586        if (ch->cm_id) {
587                ib_destroy_cm_id(ch->cm_id);
588                ch->cm_id = NULL;
589        }
590
591        /* If srp_new_cm_id() succeeded but srp_create_ch_ib() not, return. */
592        if (!ch->qp)
593                return;
594
595        if (dev->use_fast_reg) {
596                if (ch->fr_pool)
597                        srp_destroy_fr_pool(ch->fr_pool);
598        } else if (dev->use_fmr) {
599                if (ch->fmr_pool)
600                        ib_destroy_fmr_pool(ch->fmr_pool);
601        }
602
603        srp_destroy_qp(ch->qp);
604        ib_free_cq(ch->send_cq);
605        ib_free_cq(ch->recv_cq);
606
607        /*
608         * Avoid that the SCSI error handler tries to use this channel after
609         * it has been freed. The SCSI error handler can namely continue
610         * trying to perform recovery actions after scsi_remove_host()
611         * returned.
612         */
613        ch->target = NULL;
614
615        ch->qp = NULL;
616        ch->send_cq = ch->recv_cq = NULL;
617
618        if (ch->rx_ring) {
619                for (i = 0; i < target->queue_size; ++i)
620                        srp_free_iu(target->srp_host, ch->rx_ring[i]);
621                kfree(ch->rx_ring);
622                ch->rx_ring = NULL;
623        }
624        if (ch->tx_ring) {
625                for (i = 0; i < target->queue_size; ++i)
626                        srp_free_iu(target->srp_host, ch->tx_ring[i]);
627                kfree(ch->tx_ring);
628                ch->tx_ring = NULL;
629        }
630}
631
632static void srp_path_rec_completion(int status,
633                                    struct ib_sa_path_rec *pathrec,
634                                    void *ch_ptr)
635{
636        struct srp_rdma_ch *ch = ch_ptr;
637        struct srp_target_port *target = ch->target;
638
639        ch->status = status;
640        if (status)
641                shost_printk(KERN_ERR, target->scsi_host,
642                             PFX "Got failed path rec status %d\n", status);
643        else
644                ch->path = *pathrec;
645        complete(&ch->done);
646}
647
648static int srp_lookup_path(struct srp_rdma_ch *ch)
649{
650        struct srp_target_port *target = ch->target;
651        int ret;
652
653        ch->path.numb_path = 1;
654
655        init_completion(&ch->done);
656
657        ch->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
658                                               target->srp_host->srp_dev->dev,
659                                               target->srp_host->port,
660                                               &ch->path,
661                                               IB_SA_PATH_REC_SERVICE_ID |
662                                               IB_SA_PATH_REC_DGID       |
663                                               IB_SA_PATH_REC_SGID       |
664                                               IB_SA_PATH_REC_NUMB_PATH  |
665                                               IB_SA_PATH_REC_PKEY,
666                                               SRP_PATH_REC_TIMEOUT_MS,
667                                               GFP_KERNEL,
668                                               srp_path_rec_completion,
669                                               ch, &ch->path_query);
670        if (ch->path_query_id < 0)
671                return ch->path_query_id;
672
673        ret = wait_for_completion_interruptible(&ch->done);
674        if (ret < 0)
675                return ret;
676
677        if (ch->status < 0)
678                shost_printk(KERN_WARNING, target->scsi_host,
679                             PFX "Path record query failed\n");
680
681        return ch->status;
682}
683
684static int srp_send_req(struct srp_rdma_ch *ch, bool multich)
685{
686        struct srp_target_port *target = ch->target;
687        struct {
688                struct ib_cm_req_param param;
689                struct srp_login_req   priv;
690        } *req = NULL;
691        int status;
692
693        req = kzalloc(sizeof *req, GFP_KERNEL);
694        if (!req)
695                return -ENOMEM;
696
697        req->param.primary_path               = &ch->path;
698        req->param.alternate_path             = NULL;
699        req->param.service_id                 = target->service_id;
700        req->param.qp_num                     = ch->qp->qp_num;
701        req->param.qp_type                    = ch->qp->qp_type;
702        req->param.private_data               = &req->priv;
703        req->param.private_data_len           = sizeof req->priv;
704        req->param.flow_control               = 1;
705
706        get_random_bytes(&req->param.starting_psn, 4);
707        req->param.starting_psn              &= 0xffffff;
708
709        /*
710         * Pick some arbitrary defaults here; we could make these
711         * module parameters if anyone cared about setting them.
712         */
713        req->param.responder_resources        = 4;
714        req->param.remote_cm_response_timeout = 20;
715        req->param.local_cm_response_timeout  = 20;
716        req->param.retry_count                = target->tl_retry_count;
717        req->param.rnr_retry_count            = 7;
718        req->param.max_cm_retries             = 15;
719
720        req->priv.opcode        = SRP_LOGIN_REQ;
721        req->priv.tag           = 0;
722        req->priv.req_it_iu_len = cpu_to_be32(target->max_iu_len);
723        req->priv.req_buf_fmt   = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
724                                              SRP_BUF_FORMAT_INDIRECT);
725        req->priv.req_flags     = (multich ? SRP_MULTICHAN_MULTI :
726                                   SRP_MULTICHAN_SINGLE);
727        /*
728         * In the published SRP specification (draft rev. 16a), the
729         * port identifier format is 8 bytes of ID extension followed
730         * by 8 bytes of GUID.  Older drafts put the two halves in the
731         * opposite order, so that the GUID comes first.
732         *
733         * Targets conforming to these obsolete drafts can be
734         * recognized by the I/O Class they report.
735         */
736        if (target->io_class == SRP_REV10_IB_IO_CLASS) {
737                memcpy(req->priv.initiator_port_id,
738                       &target->sgid.global.interface_id, 8);
739                memcpy(req->priv.initiator_port_id + 8,
740                       &target->initiator_ext, 8);
741                memcpy(req->priv.target_port_id,     &target->ioc_guid, 8);
742                memcpy(req->priv.target_port_id + 8, &target->id_ext, 8);
743        } else {
744                memcpy(req->priv.initiator_port_id,
745                       &target->initiator_ext, 8);
746                memcpy(req->priv.initiator_port_id + 8,
747                       &target->sgid.global.interface_id, 8);
748                memcpy(req->priv.target_port_id,     &target->id_ext, 8);
749                memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8);
750        }
751
752        /*
753         * Topspin/Cisco SRP targets will reject our login unless we
754         * zero out the first 8 bytes of our initiator port ID and set
755         * the second 8 bytes to the local node GUID.
756         */
757        if (srp_target_is_topspin(target)) {
758                shost_printk(KERN_DEBUG, target->scsi_host,
759                             PFX "Topspin/Cisco initiator port ID workaround "
760                             "activated for target GUID %016llx\n",
761                             be64_to_cpu(target->ioc_guid));
762                memset(req->priv.initiator_port_id, 0, 8);
763                memcpy(req->priv.initiator_port_id + 8,
764                       &target->srp_host->srp_dev->dev->node_guid, 8);
765        }
766
767        status = ib_send_cm_req(ch->cm_id, &req->param);
768
769        kfree(req);
770
771        return status;
772}
773
774static bool srp_queue_remove_work(struct srp_target_port *target)
775{
776        bool changed = false;
777
778        spin_lock_irq(&target->lock);
779        if (target->state != SRP_TARGET_REMOVED) {
780                target->state = SRP_TARGET_REMOVED;
781                changed = true;
782        }
783        spin_unlock_irq(&target->lock);
784
785        if (changed)
786                queue_work(srp_remove_wq, &target->remove_work);
787
788        return changed;
789}
790
791static void srp_disconnect_target(struct srp_target_port *target)
792{
793        struct srp_rdma_ch *ch;
794        int i;
795
796        /* XXX should send SRP_I_LOGOUT request */
797
798        for (i = 0; i < target->ch_count; i++) {
799                ch = &target->ch[i];
800                ch->connected = false;
801                if (ch->cm_id && ib_send_cm_dreq(ch->cm_id, NULL, 0)) {
802                        shost_printk(KERN_DEBUG, target->scsi_host,
803                                     PFX "Sending CM DREQ failed\n");
804                }
805        }
806}
807
808static void srp_free_req_data(struct srp_target_port *target,
809                              struct srp_rdma_ch *ch)
810{
811        struct srp_device *dev = target->srp_host->srp_dev;
812        struct ib_device *ibdev = dev->dev;
813        struct srp_request *req;
814        int i;
815
816        if (!ch->req_ring)
817                return;
818
819        for (i = 0; i < target->req_ring_size; ++i) {
820                req = &ch->req_ring[i];
821                if (dev->use_fast_reg) {
822                        kfree(req->fr_list);
823                } else {
824                        kfree(req->fmr_list);
825                        kfree(req->map_page);
826                }
827                if (req->indirect_dma_addr) {
828                        ib_dma_unmap_single(ibdev, req->indirect_dma_addr,
829                                            target->indirect_size,
830                                            DMA_TO_DEVICE);
831                }
832                kfree(req->indirect_desc);
833        }
834
835        kfree(ch->req_ring);
836        ch->req_ring = NULL;
837}
838
839static int srp_alloc_req_data(struct srp_rdma_ch *ch)
840{
841        struct srp_target_port *target = ch->target;
842        struct srp_device *srp_dev = target->srp_host->srp_dev;
843        struct ib_device *ibdev = srp_dev->dev;
844        struct srp_request *req;
845        void *mr_list;
846        dma_addr_t dma_addr;
847        int i, ret = -ENOMEM;
848
849        ch->req_ring = kcalloc(target->req_ring_size, sizeof(*ch->req_ring),
850                               GFP_KERNEL);
851        if (!ch->req_ring)
852                goto out;
853
854        for (i = 0; i < target->req_ring_size; ++i) {
855                req = &ch->req_ring[i];
856                mr_list = kmalloc(target->mr_per_cmd * sizeof(void *),
857                                  GFP_KERNEL);
858                if (!mr_list)
859                        goto out;
860                if (srp_dev->use_fast_reg) {
861                        req->fr_list = mr_list;
862                } else {
863                        req->fmr_list = mr_list;
864                        req->map_page = kmalloc(srp_dev->max_pages_per_mr *
865                                                sizeof(void *), GFP_KERNEL);
866                        if (!req->map_page)
867                                goto out;
868                }
869                req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL);
870                if (!req->indirect_desc)
871                        goto out;
872
873                dma_addr = ib_dma_map_single(ibdev, req->indirect_desc,
874                                             target->indirect_size,
875                                             DMA_TO_DEVICE);
876                if (ib_dma_mapping_error(ibdev, dma_addr))
877                        goto out;
878
879                req->indirect_dma_addr = dma_addr;
880        }
881        ret = 0;
882
883out:
884        return ret;
885}
886
887/**
888 * srp_del_scsi_host_attr() - Remove attributes defined in the host template.
889 * @shost: SCSI host whose attributes to remove from sysfs.
890 *
891 * Note: Any attributes defined in the host template and that did not exist
892 * before invocation of this function will be ignored.
893 */
894static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
895{
896        struct device_attribute **attr;
897
898        for (attr = shost->hostt->shost_attrs; attr && *attr; ++attr)
899                device_remove_file(&shost->shost_dev, *attr);
900}
901
902static void srp_remove_target(struct srp_target_port *target)
903{
904        struct srp_rdma_ch *ch;
905        int i;
906
907        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
908
909        srp_del_scsi_host_attr(target->scsi_host);
910        srp_rport_get(target->rport);
911        srp_remove_host(target->scsi_host);
912        scsi_remove_host(target->scsi_host);
913        srp_stop_rport_timers(target->rport);
914        srp_disconnect_target(target);
915        for (i = 0; i < target->ch_count; i++) {
916                ch = &target->ch[i];
917                srp_free_ch_ib(target, ch);
918        }
919        cancel_work_sync(&target->tl_err_work);
920        srp_rport_put(target->rport);
921        for (i = 0; i < target->ch_count; i++) {
922                ch = &target->ch[i];
923                srp_free_req_data(target, ch);
924        }
925        kfree(target->ch);
926        target->ch = NULL;
927
928        spin_lock(&target->srp_host->target_lock);
929        list_del(&target->list);
930        spin_unlock(&target->srp_host->target_lock);
931
932        scsi_host_put(target->scsi_host);
933}
934
935static void srp_remove_work(struct work_struct *work)
936{
937        struct srp_target_port *target =
938                container_of(work, struct srp_target_port, remove_work);
939
940        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
941
942        srp_remove_target(target);
943}
944
945static void srp_rport_delete(struct srp_rport *rport)
946{
947        struct srp_target_port *target = rport->lld_data;
948
949        srp_queue_remove_work(target);
950}
951
952/**
953 * srp_connected_ch() - number of connected channels
954 * @target: SRP target port.
955 */
956static int srp_connected_ch(struct srp_target_port *target)
957{
958        int i, c = 0;
959
960        for (i = 0; i < target->ch_count; i++)
961                c += target->ch[i].connected;
962
963        return c;
964}
965
966static int srp_connect_ch(struct srp_rdma_ch *ch, bool multich)
967{
968        struct srp_target_port *target = ch->target;
969        int ret;
970
971        WARN_ON_ONCE(!multich && srp_connected_ch(target) > 0);
972
973        ret = srp_lookup_path(ch);
974        if (ret)
975                goto out;
976
977        while (1) {
978                init_completion(&ch->done);
979                ret = srp_send_req(ch, multich);
980                if (ret)
981                        goto out;
982                ret = wait_for_completion_interruptible(&ch->done);
983                if (ret < 0)
984                        goto out;
985
986                /*
987                 * The CM event handling code will set status to
988                 * SRP_PORT_REDIRECT if we get a port redirect REJ
989                 * back, or SRP_DLID_REDIRECT if we get a lid/qp
990                 * redirect REJ back.
991                 */
992                ret = ch->status;
993                switch (ret) {
994                case 0:
995                        ch->connected = true;
996                        goto out;
997
998                case SRP_PORT_REDIRECT:
999                        ret = srp_lookup_path(ch);
1000                        if (ret)
1001                                goto out;
1002                        break;
1003
1004                case SRP_DLID_REDIRECT:
1005                        break;
1006
1007                case SRP_STALE_CONN:
1008                        shost_printk(KERN_ERR, target->scsi_host, PFX
1009                                     "giving up on stale connection\n");
1010                        ret = -ECONNRESET;
1011                        goto out;
1012
1013                default:
1014                        goto out;
1015                }
1016        }
1017
1018out:
1019        return ret <= 0 ? ret : -ENODEV;
1020}
1021
1022static void srp_inv_rkey_err_done(struct ib_cq *cq, struct ib_wc *wc)
1023{
1024        srp_handle_qp_err(cq, wc, "INV RKEY");
1025}
1026
1027static int srp_inv_rkey(struct srp_request *req, struct srp_rdma_ch *ch,
1028                u32 rkey)
1029{
1030        struct ib_send_wr *bad_wr;
1031        struct ib_send_wr wr = {
1032                .opcode             = IB_WR_LOCAL_INV,
1033                .next               = NULL,
1034                .num_sge            = 0,
1035                .send_flags         = 0,
1036                .ex.invalidate_rkey = rkey,
1037        };
1038
1039        wr.wr_cqe = &req->reg_cqe;
1040        req->reg_cqe.done = srp_inv_rkey_err_done;
1041        return ib_post_send(ch->qp, &wr, &bad_wr);
1042}
1043
1044static void srp_unmap_data(struct scsi_cmnd *scmnd,
1045                           struct srp_rdma_ch *ch,
1046                           struct srp_request *req)
1047{
1048        struct srp_target_port *target = ch->target;
1049        struct srp_device *dev = target->srp_host->srp_dev;
1050        struct ib_device *ibdev = dev->dev;
1051        int i, res;
1052
1053        if (!scsi_sglist(scmnd) ||
1054            (scmnd->sc_data_direction != DMA_TO_DEVICE &&
1055             scmnd->sc_data_direction != DMA_FROM_DEVICE))
1056                return;
1057
1058        if (dev->use_fast_reg) {
1059                struct srp_fr_desc **pfr;
1060
1061                for (i = req->nmdesc, pfr = req->fr_list; i > 0; i--, pfr++) {
1062                        res = srp_inv_rkey(req, ch, (*pfr)->mr->rkey);
1063                        if (res < 0) {
1064                                shost_printk(KERN_ERR, target->scsi_host, PFX
1065                                  "Queueing INV WR for rkey %#x failed (%d)\n",
1066                                  (*pfr)->mr->rkey, res);
1067                                queue_work(system_long_wq,
1068                                           &target->tl_err_work);
1069                        }
1070                }
1071                if (req->nmdesc)
1072                        srp_fr_pool_put(ch->fr_pool, req->fr_list,
1073                                        req->nmdesc);
1074        } else if (dev->use_fmr) {
1075                struct ib_pool_fmr **pfmr;
1076
1077                for (i = req->nmdesc, pfmr = req->fmr_list; i > 0; i--, pfmr++)
1078                        ib_fmr_pool_unmap(*pfmr);
1079        }
1080
1081        ib_dma_unmap_sg(ibdev, scsi_sglist(scmnd), scsi_sg_count(scmnd),
1082                        scmnd->sc_data_direction);
1083}
1084
1085/**
1086 * srp_claim_req - Take ownership of the scmnd associated with a request.
1087 * @ch: SRP RDMA channel.
1088 * @req: SRP request.
1089 * @sdev: If not NULL, only take ownership for this SCSI device.
1090 * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
1091 *         ownership of @req->scmnd if it equals @scmnd.
1092 *
1093 * Return value:
1094 * Either NULL or a pointer to the SCSI command the caller became owner of.
1095 */
1096static struct scsi_cmnd *srp_claim_req(struct srp_rdma_ch *ch,
1097                                       struct srp_request *req,
1098                                       struct scsi_device *sdev,
1099                                       struct scsi_cmnd *scmnd)
1100{
1101        unsigned long flags;
1102
1103        spin_lock_irqsave(&ch->lock, flags);
1104        if (req->scmnd &&
1105            (!sdev || req->scmnd->device == sdev) &&
1106            (!scmnd || req->scmnd == scmnd)) {
1107                scmnd = req->scmnd;
1108                req->scmnd = NULL;
1109        } else {
1110                scmnd = NULL;
1111        }
1112        spin_unlock_irqrestore(&ch->lock, flags);
1113
1114        return scmnd;
1115}
1116
1117/**
1118 * srp_free_req() - Unmap data and adjust ch->req_lim.
1119 * @ch:     SRP RDMA channel.
1120 * @req:    Request to be freed.
1121 * @scmnd:  SCSI command associated with @req.
1122 * @req_lim_delta: Amount to be added to @target->req_lim.
1123 */
1124static void srp_free_req(struct srp_rdma_ch *ch, struct srp_request *req,
1125                         struct scsi_cmnd *scmnd, s32 req_lim_delta)
1126{
1127        unsigned long flags;
1128
1129        srp_unmap_data(scmnd, ch, req);
1130
1131        spin_lock_irqsave(&ch->lock, flags);
1132        ch->req_lim += req_lim_delta;
1133        spin_unlock_irqrestore(&ch->lock, flags);
1134}
1135
1136static void srp_finish_req(struct srp_rdma_ch *ch, struct srp_request *req,
1137                           struct scsi_device *sdev, int result)
1138{
1139        struct scsi_cmnd *scmnd = srp_claim_req(ch, req, sdev, NULL);
1140
1141        if (scmnd) {
1142                srp_free_req(ch, req, scmnd, 0);
1143                scmnd->result = result;
1144                scmnd->scsi_done(scmnd);
1145        }
1146}
1147
1148static void srp_terminate_io(struct srp_rport *rport)
1149{
1150        struct srp_target_port *target = rport->lld_data;
1151        struct srp_rdma_ch *ch;
1152        struct Scsi_Host *shost = target->scsi_host;
1153        struct scsi_device *sdev;
1154        int i, j;
1155
1156        /*
1157         * Invoking srp_terminate_io() while srp_queuecommand() is running
1158         * is not safe. Hence the warning statement below.
1159         */
1160        shost_for_each_device(sdev, shost)
1161                WARN_ON_ONCE(sdev->request_queue->request_fn_active);
1162
1163        for (i = 0; i < target->ch_count; i++) {
1164                ch = &target->ch[i];
1165
1166                for (j = 0; j < target->req_ring_size; ++j) {
1167                        struct srp_request *req = &ch->req_ring[j];
1168
1169                        srp_finish_req(ch, req, NULL,
1170                                       DID_TRANSPORT_FAILFAST << 16);
1171                }
1172        }
1173}
1174
1175/*
1176 * It is up to the caller to ensure that srp_rport_reconnect() calls are
1177 * serialized and that no concurrent srp_queuecommand(), srp_abort(),
1178 * srp_reset_device() or srp_reset_host() calls will occur while this function
1179 * is in progress. One way to realize that is not to call this function
1180 * directly but to call srp_reconnect_rport() instead since that last function
1181 * serializes calls of this function via rport->mutex and also blocks
1182 * srp_queuecommand() calls before invoking this function.
1183 */
1184static int srp_rport_reconnect(struct srp_rport *rport)
1185{
1186        struct srp_target_port *target = rport->lld_data;
1187        struct srp_rdma_ch *ch;
1188        int i, j, ret = 0;
1189        bool multich = false;
1190
1191        srp_disconnect_target(target);
1192
1193        if (target->state == SRP_TARGET_SCANNING)
1194                return -ENODEV;
1195
1196        /*
1197         * Now get a new local CM ID so that we avoid confusing the target in
1198         * case things are really fouled up. Doing so also ensures that all CM
1199         * callbacks will have finished before a new QP is allocated.
1200         */
1201        for (i = 0; i < target->ch_count; i++) {
1202                ch = &target->ch[i];
1203                ret += srp_new_cm_id(ch);
1204        }
1205        for (i = 0; i < target->ch_count; i++) {
1206                ch = &target->ch[i];
1207                for (j = 0; j < target->req_ring_size; ++j) {
1208                        struct srp_request *req = &ch->req_ring[j];
1209
1210                        srp_finish_req(ch, req, NULL, DID_RESET << 16);
1211                }
1212        }
1213        for (i = 0; i < target->ch_count; i++) {
1214                ch = &target->ch[i];
1215                /*
1216                 * Whether or not creating a new CM ID succeeded, create a new
1217                 * QP. This guarantees that all completion callback function
1218                 * invocations have finished before request resetting starts.
1219                 */
1220                ret += srp_create_ch_ib(ch);
1221
1222                INIT_LIST_HEAD(&ch->free_tx);
1223                for (j = 0; j < target->queue_size; ++j)
1224                        list_add(&ch->tx_ring[j]->list, &ch->free_tx);
1225        }
1226
1227        target->qp_in_error = false;
1228
1229        for (i = 0; i < target->ch_count; i++) {
1230                ch = &target->ch[i];
1231                if (ret)
1232                        break;
1233                ret = srp_connect_ch(ch, multich);
1234                multich = true;
1235        }
1236
1237        if (ret == 0)
1238                shost_printk(KERN_INFO, target->scsi_host,
1239                             PFX "reconnect succeeded\n");
1240
1241        return ret;
1242}
1243
1244static void srp_map_desc(struct srp_map_state *state, dma_addr_t dma_addr,
1245                         unsigned int dma_len, u32 rkey)
1246{
1247        struct srp_direct_buf *desc = state->desc;
1248
1249        WARN_ON_ONCE(!dma_len);
1250
1251        desc->va = cpu_to_be64(dma_addr);
1252        desc->key = cpu_to_be32(rkey);
1253        desc->len = cpu_to_be32(dma_len);
1254
1255        state->total_len += dma_len;
1256        state->desc++;
1257        state->ndesc++;
1258}
1259
1260static int srp_map_finish_fmr(struct srp_map_state *state,
1261                              struct srp_rdma_ch *ch)
1262{
1263        struct srp_target_port *target = ch->target;
1264        struct srp_device *dev = target->srp_host->srp_dev;
1265        struct ib_pd *pd = target->pd;
1266        struct ib_pool_fmr *fmr;
1267        u64 io_addr = 0;
1268
1269        if (state->fmr.next >= state->fmr.end)
1270                return -ENOMEM;
1271
1272        WARN_ON_ONCE(!dev->use_fmr);
1273
1274        if (state->npages == 0)
1275                return 0;
1276
1277        if (state->npages == 1 && (pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY)) {
1278                srp_map_desc(state, state->base_dma_addr, state->dma_len,
1279                             pd->unsafe_global_rkey);
1280                goto reset_state;
1281        }
1282
1283        fmr = ib_fmr_pool_map_phys(ch->fmr_pool, state->pages,
1284                                   state->npages, io_addr);
1285        if (IS_ERR(fmr))
1286                return PTR_ERR(fmr);
1287
1288        *state->fmr.next++ = fmr;
1289        state->nmdesc++;
1290
1291        srp_map_desc(state, state->base_dma_addr & ~dev->mr_page_mask,
1292                     state->dma_len, fmr->fmr->rkey);
1293
1294reset_state:
1295        state->npages = 0;
1296        state->dma_len = 0;
1297
1298        return 0;
1299}
1300
1301static void srp_reg_mr_err_done(struct ib_cq *cq, struct ib_wc *wc)
1302{
1303        srp_handle_qp_err(cq, wc, "FAST REG");
1304}
1305
1306/*
1307 * Map up to sg_nents elements of state->sg where *sg_offset_p is the offset
1308 * where to start in the first element. If sg_offset_p != NULL then
1309 * *sg_offset_p is updated to the offset in state->sg[retval] of the first
1310 * byte that has not yet been mapped.
1311 */
1312static int srp_map_finish_fr(struct srp_map_state *state,
1313                             struct srp_request *req,
1314                             struct srp_rdma_ch *ch, int sg_nents,
1315                             unsigned int *sg_offset_p)
1316{
1317        struct srp_target_port *target = ch->target;
1318        struct srp_device *dev = target->srp_host->srp_dev;
1319        struct ib_pd *pd = target->pd;
1320        struct ib_send_wr *bad_wr;
1321        struct ib_reg_wr wr;
1322        struct srp_fr_desc *desc;
1323        u32 rkey;
1324        int n, err;
1325
1326        if (state->fr.next >= state->fr.end)
1327                return -ENOMEM;
1328
1329        WARN_ON_ONCE(!dev->use_fast_reg);
1330
1331        if (sg_nents == 1 && (pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY)) {
1332                unsigned int sg_offset = sg_offset_p ? *sg_offset_p : 0;
1333
1334                srp_map_desc(state, sg_dma_address(state->sg) + sg_offset,
1335                             sg_dma_len(state->sg) - sg_offset,
1336                             pd->unsafe_global_rkey);
1337                if (sg_offset_p)
1338                        *sg_offset_p = 0;
1339                return 1;
1340        }
1341
1342        desc = srp_fr_pool_get(ch->fr_pool);
1343        if (!desc)
1344                return -ENOMEM;
1345
1346        rkey = ib_inc_rkey(desc->mr->rkey);
1347        ib_update_fast_reg_key(desc->mr, rkey);
1348
1349        n = ib_map_mr_sg(desc->mr, state->sg, sg_nents, sg_offset_p,
1350                         dev->mr_page_size);
1351        if (unlikely(n < 0)) {
1352                srp_fr_pool_put(ch->fr_pool, &desc, 1);
1353                pr_debug("%s: ib_map_mr_sg(%d, %d) returned %d.\n",
1354                         dev_name(&req->scmnd->device->sdev_gendev), sg_nents,
1355                         sg_offset_p ? *sg_offset_p : -1, n);
1356                return n;
1357        }
1358
1359        WARN_ON_ONCE(desc->mr->length == 0);
1360
1361        req->reg_cqe.done = srp_reg_mr_err_done;
1362
1363        wr.wr.next = NULL;
1364        wr.wr.opcode = IB_WR_REG_MR;
1365        wr.wr.wr_cqe = &req->reg_cqe;
1366        wr.wr.num_sge = 0;
1367        wr.wr.send_flags = 0;
1368        wr.mr = desc->mr;
1369        wr.key = desc->mr->rkey;
1370        wr.access = (IB_ACCESS_LOCAL_WRITE |
1371                     IB_ACCESS_REMOTE_READ |
1372                     IB_ACCESS_REMOTE_WRITE);
1373
1374        *state->fr.next++ = desc;
1375        state->nmdesc++;
1376
1377        srp_map_desc(state, desc->mr->iova,
1378                     desc->mr->length, desc->mr->rkey);
1379
1380        err = ib_post_send(ch->qp, &wr.wr, &bad_wr);
1381        if (unlikely(err)) {
1382                WARN_ON_ONCE(err == -ENOMEM);
1383                return err;
1384        }
1385
1386        return n;
1387}
1388
1389static int srp_map_sg_entry(struct srp_map_state *state,
1390                            struct srp_rdma_ch *ch,
1391                            struct scatterlist *sg)
1392{
1393        struct srp_target_port *target = ch->target;
1394        struct srp_device *dev = target->srp_host->srp_dev;
1395        struct ib_device *ibdev = dev->dev;
1396        dma_addr_t dma_addr = ib_sg_dma_address(ibdev, sg);
1397        unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
1398        unsigned int len = 0;
1399        int ret;
1400
1401        WARN_ON_ONCE(!dma_len);
1402
1403        while (dma_len) {
1404                unsigned offset = dma_addr & ~dev->mr_page_mask;
1405
1406                if (state->npages == dev->max_pages_per_mr ||
1407                    (state->npages > 0 && offset != 0)) {
1408                        ret = srp_map_finish_fmr(state, ch);
1409                        if (ret)
1410                                return ret;
1411                }
1412
1413                len = min_t(unsigned int, dma_len, dev->mr_page_size - offset);
1414
1415                if (!state->npages)
1416                        state->base_dma_addr = dma_addr;
1417                state->pages[state->npages++] = dma_addr & dev->mr_page_mask;
1418                state->dma_len += len;
1419                dma_addr += len;
1420                dma_len -= len;
1421        }
1422
1423        /*
1424         * If the end of the MR is not on a page boundary then we need to
1425         * close it out and start a new one -- we can only merge at page
1426         * boundaries.
1427         */
1428        ret = 0;
1429        if ((dma_addr & ~dev->mr_page_mask) != 0)
1430                ret = srp_map_finish_fmr(state, ch);
1431        return ret;
1432}
1433
1434static int srp_map_sg_fmr(struct srp_map_state *state, struct srp_rdma_ch *ch,
1435                          struct srp_request *req, struct scatterlist *scat,
1436                          int count)
1437{
1438        struct scatterlist *sg;
1439        int i, ret;
1440
1441        state->pages = req->map_page;
1442        state->fmr.next = req->fmr_list;
1443        state->fmr.end = req->fmr_list + ch->target->mr_per_cmd;
1444
1445        for_each_sg(scat, sg, count, i) {
1446                ret = srp_map_sg_entry(state, ch, sg);
1447                if (ret)
1448                        return ret;
1449        }
1450
1451        ret = srp_map_finish_fmr(state, ch);
1452        if (ret)
1453                return ret;
1454
1455        return 0;
1456}
1457
1458static int srp_map_sg_fr(struct srp_map_state *state, struct srp_rdma_ch *ch,
1459                         struct srp_request *req, struct scatterlist *scat,
1460                         int count)
1461{
1462        unsigned int sg_offset = 0;
1463
1464        state->fr.next = req->fr_list;
1465        state->fr.end = req->fr_list + ch->target->mr_per_cmd;
1466        state->sg = scat;
1467
1468        if (count == 0)
1469                return 0;
1470
1471        while (count) {
1472                int i, n;
1473
1474                n = srp_map_finish_fr(state, req, ch, count, &sg_offset);
1475                if (unlikely(n < 0))
1476                        return n;
1477
1478                count -= n;
1479                for (i = 0; i < n; i++)
1480                        state->sg = sg_next(state->sg);
1481        }
1482
1483        return 0;
1484}
1485
1486static int srp_map_sg_dma(struct srp_map_state *state, struct srp_rdma_ch *ch,
1487                          struct srp_request *req, struct scatterlist *scat,
1488                          int count)
1489{
1490        struct srp_target_port *target = ch->target;
1491        struct srp_device *dev = target->srp_host->srp_dev;
1492        struct scatterlist *sg;
1493        int i;
1494
1495        for_each_sg(scat, sg, count, i) {
1496                srp_map_desc(state, ib_sg_dma_address(dev->dev, sg),
1497                             ib_sg_dma_len(dev->dev, sg),
1498                             target->pd->unsafe_global_rkey);
1499        }
1500
1501        return 0;
1502}
1503
1504/*
1505 * Register the indirect data buffer descriptor with the HCA.
1506 *
1507 * Note: since the indirect data buffer descriptor has been allocated with
1508 * kmalloc() it is guaranteed that this buffer is a physically contiguous
1509 * memory buffer.
1510 */
1511static int srp_map_idb(struct srp_rdma_ch *ch, struct srp_request *req,
1512                       void **next_mr, void **end_mr, u32 idb_len,
1513                       __be32 *idb_rkey)
1514{
1515        struct srp_target_port *target = ch->target;
1516        struct srp_device *dev = target->srp_host->srp_dev;
1517        struct srp_map_state state;
1518        struct srp_direct_buf idb_desc;
1519        u64 idb_pages[1];
1520        struct scatterlist idb_sg[1];
1521        int ret;
1522
1523        memset(&state, 0, sizeof(state));
1524        memset(&idb_desc, 0, sizeof(idb_desc));
1525        state.gen.next = next_mr;
1526        state.gen.end = end_mr;
1527        state.desc = &idb_desc;
1528        state.base_dma_addr = req->indirect_dma_addr;
1529        state.dma_len = idb_len;
1530
1531        if (dev->use_fast_reg) {
1532                state.sg = idb_sg;
1533                sg_init_one(idb_sg, req->indirect_desc, idb_len);
1534                idb_sg->dma_address = req->indirect_dma_addr; /* hack! */
1535#ifdef CONFIG_NEED_SG_DMA_LENGTH
1536                idb_sg->dma_length = idb_sg->length;          /* hack^2 */
1537#endif
1538                ret = srp_map_finish_fr(&state, req, ch, 1, NULL);
1539                if (ret < 0)
1540                        return ret;
1541                WARN_ON_ONCE(ret < 1);
1542        } else if (dev->use_fmr) {
1543                state.pages = idb_pages;
1544                state.pages[0] = (req->indirect_dma_addr &
1545                                  dev->mr_page_mask);
1546                state.npages = 1;
1547                ret = srp_map_finish_fmr(&state, ch);
1548                if (ret < 0)
1549                        return ret;
1550        } else {
1551                return -EINVAL;
1552        }
1553
1554        *idb_rkey = idb_desc.key;
1555
1556        return 0;
1557}
1558
1559#if defined(DYNAMIC_DATA_DEBUG)
1560static void srp_check_mapping(struct srp_map_state *state,
1561                              struct srp_rdma_ch *ch, struct srp_request *req,
1562                              struct scatterlist *scat, int count)
1563{
1564        struct srp_device *dev = ch->target->srp_host->srp_dev;
1565        struct srp_fr_desc **pfr;
1566        u64 desc_len = 0, mr_len = 0;
1567        int i;
1568
1569        for (i = 0; i < state->ndesc; i++)
1570                desc_len += be32_to_cpu(req->indirect_desc[i].len);
1571        if (dev->use_fast_reg)
1572                for (i = 0, pfr = req->fr_list; i < state->nmdesc; i++, pfr++)
1573                        mr_len += (*pfr)->mr->length;
1574        else if (dev->use_fmr)
1575                for (i = 0; i < state->nmdesc; i++)
1576                        mr_len += be32_to_cpu(req->indirect_desc[i].len);
1577        if (desc_len != scsi_bufflen(req->scmnd) ||
1578            mr_len > scsi_bufflen(req->scmnd))
1579                pr_err("Inconsistent: scsi len %d <> desc len %lld <> mr len %lld; ndesc %d; nmdesc = %d\n",
1580                       scsi_bufflen(req->scmnd), desc_len, mr_len,
1581                       state->ndesc, state->nmdesc);
1582}
1583#endif
1584
1585/**
1586 * srp_map_data() - map SCSI data buffer onto an SRP request
1587 * @scmnd: SCSI command to map
1588 * @ch: SRP RDMA channel
1589 * @req: SRP request
1590 *
1591 * Returns the length in bytes of the SRP_CMD IU or a negative value if
1592 * mapping failed.
1593 */
1594static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_rdma_ch *ch,
1595                        struct srp_request *req)
1596{
1597        struct srp_target_port *target = ch->target;
1598        struct ib_pd *pd = target->pd;
1599        struct scatterlist *scat;
1600        struct srp_cmd *cmd = req->cmd->buf;
1601        int len, nents, count, ret;
1602        struct srp_device *dev;
1603        struct ib_device *ibdev;
1604        struct srp_map_state state;
1605        struct srp_indirect_buf *indirect_hdr;
1606        u32 idb_len, table_len;
1607        __be32 idb_rkey;
1608        u8 fmt;
1609
1610        if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE)
1611                return sizeof (struct srp_cmd);
1612
1613        if (scmnd->sc_data_direction != DMA_FROM_DEVICE &&
1614            scmnd->sc_data_direction != DMA_TO_DEVICE) {
1615                shost_printk(KERN_WARNING, target->scsi_host,
1616                             PFX "Unhandled data direction %d\n",
1617                             scmnd->sc_data_direction);
1618                return -EINVAL;
1619        }
1620
1621        nents = scsi_sg_count(scmnd);
1622        scat  = scsi_sglist(scmnd);
1623
1624        dev = target->srp_host->srp_dev;
1625        ibdev = dev->dev;
1626
1627        count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
1628        if (unlikely(count == 0))
1629                return -EIO;
1630
1631        fmt = SRP_DATA_DESC_DIRECT;
1632        len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf);
1633
1634        if (count == 1 && (pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY)) {
1635                /*
1636                 * The midlayer only generated a single gather/scatter
1637                 * entry, or DMA mapping coalesced everything to a
1638                 * single entry.  So a direct descriptor along with
1639                 * the DMA MR suffices.
1640                 */
1641                struct srp_direct_buf *buf = (void *) cmd->add_data;
1642
1643                buf->va  = cpu_to_be64(ib_sg_dma_address(ibdev, scat));
1644                buf->key = cpu_to_be32(pd->unsafe_global_rkey);
1645                buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat));
1646
1647                req->nmdesc = 0;
1648                goto map_complete;
1649        }
1650
1651        /*
1652         * We have more than one scatter/gather entry, so build our indirect
1653         * descriptor table, trying to merge as many entries as we can.
1654         */
1655        indirect_hdr = (void *) cmd->add_data;
1656
1657        ib_dma_sync_single_for_cpu(ibdev, req->indirect_dma_addr,
1658                                   target->indirect_size, DMA_TO_DEVICE);
1659
1660        memset(&state, 0, sizeof(state));
1661        state.desc = req->indirect_desc;
1662        if (dev->use_fast_reg)
1663                ret = srp_map_sg_fr(&state, ch, req, scat, count);
1664        else if (dev->use_fmr)
1665                ret = srp_map_sg_fmr(&state, ch, req, scat, count);
1666        else
1667                ret = srp_map_sg_dma(&state, ch, req, scat, count);
1668        req->nmdesc = state.nmdesc;
1669        if (ret < 0)
1670                goto unmap;
1671
1672#if defined(DYNAMIC_DEBUG)
1673        {
1674                DEFINE_DYNAMIC_DEBUG_METADATA(ddm,
1675                        "Memory mapping consistency check");
1676                if (unlikely(ddm.flags & _DPRINTK_FLAGS_PRINT))
1677                        srp_check_mapping(&state, ch, req, scat, count);
1678        }
1679#endif
1680
1681        /* We've mapped the request, now pull as much of the indirect
1682         * descriptor table as we can into the command buffer. If this
1683         * target is not using an external indirect table, we are
1684         * guaranteed to fit into the command, as the SCSI layer won't
1685         * give us more S/G entries than we allow.
1686         */
1687        if (state.ndesc == 1) {
1688                /*
1689                 * Memory registration collapsed the sg-list into one entry,
1690                 * so use a direct descriptor.
1691                 */
1692                struct srp_direct_buf *buf = (void *) cmd->add_data;
1693
1694                *buf = req->indirect_desc[0];
1695                goto map_complete;
1696        }
1697
1698        if (unlikely(target->cmd_sg_cnt < state.ndesc &&
1699                                                !target->allow_ext_sg)) {
1700                shost_printk(KERN_ERR, target->scsi_host,
1701                             "Could not fit S/G list into SRP_CMD\n");
1702                ret = -EIO;
1703                goto unmap;
1704        }
1705
1706        count = min(state.ndesc, target->cmd_sg_cnt);
1707        table_len = state.ndesc * sizeof (struct srp_direct_buf);
1708        idb_len = sizeof(struct srp_indirect_buf) + table_len;
1709
1710        fmt = SRP_DATA_DESC_INDIRECT;
1711        len = sizeof(struct srp_cmd) + sizeof (struct srp_indirect_buf);
1712        len += count * sizeof (struct srp_direct_buf);
1713
1714        memcpy(indirect_hdr->desc_list, req->indirect_desc,
1715               count * sizeof (struct srp_direct_buf));
1716
1717        if (!(pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY)) {
1718                ret = srp_map_idb(ch, req, state.gen.next, state.gen.end,
1719                                  idb_len, &idb_rkey);
1720                if (ret < 0)
1721                        goto unmap;
1722                req->nmdesc++;
1723        } else {
1724                idb_rkey = cpu_to_be32(pd->unsafe_global_rkey);
1725        }
1726
1727        indirect_hdr->table_desc.va = cpu_to_be64(req->indirect_dma_addr);
1728        indirect_hdr->table_desc.key = idb_rkey;
1729        indirect_hdr->table_desc.len = cpu_to_be32(table_len);
1730        indirect_hdr->len = cpu_to_be32(state.total_len);
1731
1732        if (scmnd->sc_data_direction == DMA_TO_DEVICE)
1733                cmd->data_out_desc_cnt = count;
1734        else
1735                cmd->data_in_desc_cnt = count;
1736
1737        ib_dma_sync_single_for_device(ibdev, req->indirect_dma_addr, table_len,
1738                                      DMA_TO_DEVICE);
1739
1740map_complete:
1741        if (scmnd->sc_data_direction == DMA_TO_DEVICE)
1742                cmd->buf_fmt = fmt << 4;
1743        else
1744                cmd->buf_fmt = fmt;
1745
1746        return len;
1747
1748unmap:
1749        srp_unmap_data(scmnd, ch, req);
1750        if (ret == -ENOMEM && req->nmdesc >= target->mr_pool_size)
1751                ret = -E2BIG;
1752        return ret;
1753}
1754
1755/*
1756 * Return an IU and possible credit to the free pool
1757 */
1758static void srp_put_tx_iu(struct srp_rdma_ch *ch, struct srp_iu *iu,
1759                          enum srp_iu_type iu_type)
1760{
1761        unsigned long flags;
1762
1763        spin_lock_irqsave(&ch->lock, flags);
1764        list_add(&iu->list, &ch->free_tx);
1765        if (iu_type != SRP_IU_RSP)
1766                ++ch->req_lim;
1767        spin_unlock_irqrestore(&ch->lock, flags);
1768}
1769
1770/*
1771 * Must be called with ch->lock held to protect req_lim and free_tx.
1772 * If IU is not sent, it must be returned using srp_put_tx_iu().
1773 *
1774 * Note:
1775 * An upper limit for the number of allocated information units for each
1776 * request type is:
1777 * - SRP_IU_CMD: SRP_CMD_SQ_SIZE, since the SCSI mid-layer never queues
1778 *   more than Scsi_Host.can_queue requests.
1779 * - SRP_IU_TSK_MGMT: SRP_TSK_MGMT_SQ_SIZE.
1780 * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than
1781 *   one unanswered SRP request to an initiator.
1782 */
1783static struct srp_iu *__srp_get_tx_iu(struct srp_rdma_ch *ch,
1784                                      enum srp_iu_type iu_type)
1785{
1786        struct srp_target_port *target = ch->target;
1787        s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE;
1788        struct srp_iu *iu;
1789
1790        ib_process_cq_direct(ch->send_cq, -1);
1791
1792        if (list_empty(&ch->free_tx))
1793                return NULL;
1794
1795        /* Initiator responses to target requests do not consume credits */
1796        if (iu_type != SRP_IU_RSP) {
1797                if (ch->req_lim <= rsv) {
1798                        ++target->zero_req_lim;
1799                        return NULL;
1800                }
1801
1802                --ch->req_lim;
1803        }
1804
1805        iu = list_first_entry(&ch->free_tx, struct srp_iu, list);
1806        list_del(&iu->list);
1807        return iu;
1808}
1809
1810static void srp_send_done(struct ib_cq *cq, struct ib_wc *wc)
1811{
1812        struct srp_iu *iu = container_of(wc->wr_cqe, struct srp_iu, cqe);
1813        struct srp_rdma_ch *ch = cq->cq_context;
1814
1815        if (unlikely(wc->status != IB_WC_SUCCESS)) {
1816                srp_handle_qp_err(cq, wc, "SEND");
1817                return;
1818        }
1819
1820        list_add(&iu->list, &ch->free_tx);
1821}
1822
1823static int srp_post_send(struct srp_rdma_ch *ch, struct srp_iu *iu, int len)
1824{
1825        struct srp_target_port *target = ch->target;
1826        struct ib_sge list;
1827        struct ib_send_wr wr, *bad_wr;
1828
1829        list.addr   = iu->dma;
1830        list.length = len;
1831        list.lkey   = target->lkey;
1832
1833        iu->cqe.done = srp_send_done;
1834
1835        wr.next       = NULL;
1836        wr.wr_cqe     = &iu->cqe;
1837        wr.sg_list    = &list;
1838        wr.num_sge    = 1;
1839        wr.opcode     = IB_WR_SEND;
1840        wr.send_flags = IB_SEND_SIGNALED;
1841
1842        return ib_post_send(ch->qp, &wr, &bad_wr);
1843}
1844
1845static int srp_post_recv(struct srp_rdma_ch *ch, struct srp_iu *iu)
1846{
1847        struct srp_target_port *target = ch->target;
1848        struct ib_recv_wr wr, *bad_wr;
1849        struct ib_sge list;
1850
1851        list.addr   = iu->dma;
1852        list.length = iu->size;
1853        list.lkey   = target->lkey;
1854
1855        iu->cqe.done = srp_recv_done;
1856
1857        wr.next     = NULL;
1858        wr.wr_cqe   = &iu->cqe;
1859        wr.sg_list  = &list;
1860        wr.num_sge  = 1;
1861
1862        return ib_post_recv(ch->qp, &wr, &bad_wr);
1863}
1864
1865static void srp_process_rsp(struct srp_rdma_ch *ch, struct srp_rsp *rsp)
1866{
1867        struct srp_target_port *target = ch->target;
1868        struct srp_request *req;
1869        struct scsi_cmnd *scmnd;
1870        unsigned long flags;
1871
1872        if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) {
1873                spin_lock_irqsave(&ch->lock, flags);
1874                ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
1875                if (rsp->tag == ch->tsk_mgmt_tag) {
1876                        ch->tsk_mgmt_status = -1;
1877                        if (be32_to_cpu(rsp->resp_data_len) >= 4)
1878                                ch->tsk_mgmt_status = rsp->data[3];
1879                        complete(&ch->tsk_mgmt_done);
1880                } else {
1881                        shost_printk(KERN_ERR, target->scsi_host,
1882                                     "Received tsk mgmt response too late for tag %#llx\n",
1883                                     rsp->tag);
1884                }
1885                spin_unlock_irqrestore(&ch->lock, flags);
1886        } else {
1887                scmnd = scsi_host_find_tag(target->scsi_host, rsp->tag);
1888                if (scmnd && scmnd->host_scribble) {
1889                        req = (void *)scmnd->host_scribble;
1890                        scmnd = srp_claim_req(ch, req, NULL, scmnd);
1891                } else {
1892                        scmnd = NULL;
1893                }
1894                if (!scmnd) {
1895                        shost_printk(KERN_ERR, target->scsi_host,
1896                                     "Null scmnd for RSP w/tag %#016llx received on ch %td / QP %#x\n",
1897                                     rsp->tag, ch - target->ch, ch->qp->qp_num);
1898
1899                        spin_lock_irqsave(&ch->lock, flags);
1900                        ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
1901                        spin_unlock_irqrestore(&ch->lock, flags);
1902
1903                        return;
1904                }
1905                scmnd->result = rsp->status;
1906
1907                if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
1908                        memcpy(scmnd->sense_buffer, rsp->data +
1909                               be32_to_cpu(rsp->resp_data_len),
1910                               min_t(int, be32_to_cpu(rsp->sense_data_len),
1911                                     SCSI_SENSE_BUFFERSIZE));
1912                }
1913
1914                if (unlikely(rsp->flags & SRP_RSP_FLAG_DIUNDER))
1915                        scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
1916                else if (unlikely(rsp->flags & SRP_RSP_FLAG_DIOVER))
1917                        scsi_set_resid(scmnd, -be32_to_cpu(rsp->data_in_res_cnt));
1918                else if (unlikely(rsp->flags & SRP_RSP_FLAG_DOUNDER))
1919                        scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt));
1920                else if (unlikely(rsp->flags & SRP_RSP_FLAG_DOOVER))
1921                        scsi_set_resid(scmnd, -be32_to_cpu(rsp->data_out_res_cnt));
1922
1923                srp_free_req(ch, req, scmnd,
1924                             be32_to_cpu(rsp->req_lim_delta));
1925
1926                scmnd->host_scribble = NULL;
1927                scmnd->scsi_done(scmnd);
1928        }
1929}
1930
1931static int srp_response_common(struct srp_rdma_ch *ch, s32 req_delta,
1932                               void *rsp, int len)
1933{
1934        struct srp_target_port *target = ch->target;
1935        struct ib_device *dev = target->srp_host->srp_dev->dev;
1936        unsigned long flags;
1937        struct srp_iu *iu;
1938        int err;
1939
1940        spin_lock_irqsave(&ch->lock, flags);
1941        ch->req_lim += req_delta;
1942        iu = __srp_get_tx_iu(ch, SRP_IU_RSP);
1943        spin_unlock_irqrestore(&ch->lock, flags);
1944
1945        if (!iu) {
1946                shost_printk(KERN_ERR, target->scsi_host, PFX
1947                             "no IU available to send response\n");
1948                return 1;
1949        }
1950
1951        ib_dma_sync_single_for_cpu(dev, iu->dma, len, DMA_TO_DEVICE);
1952        memcpy(iu->buf, rsp, len);
1953        ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE);
1954
1955        err = srp_post_send(ch, iu, len);
1956        if (err) {
1957                shost_printk(KERN_ERR, target->scsi_host, PFX
1958                             "unable to post response: %d\n", err);
1959                srp_put_tx_iu(ch, iu, SRP_IU_RSP);
1960        }
1961
1962        return err;
1963}
1964
1965static void srp_process_cred_req(struct srp_rdma_ch *ch,
1966                                 struct srp_cred_req *req)
1967{
1968        struct srp_cred_rsp rsp = {
1969                .opcode = SRP_CRED_RSP,
1970                .tag = req->tag,
1971        };
1972        s32 delta = be32_to_cpu(req->req_lim_delta);
1973
1974        if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
1975                shost_printk(KERN_ERR, ch->target->scsi_host, PFX
1976                             "problems processing SRP_CRED_REQ\n");
1977}
1978
1979static void srp_process_aer_req(struct srp_rdma_ch *ch,
1980                                struct srp_aer_req *req)
1981{
1982        struct srp_target_port *target = ch->target;
1983        struct srp_aer_rsp rsp = {
1984                .opcode = SRP_AER_RSP,
1985                .tag = req->tag,
1986        };
1987        s32 delta = be32_to_cpu(req->req_lim_delta);
1988
1989        shost_printk(KERN_ERR, target->scsi_host, PFX
1990                     "ignoring AER for LUN %llu\n", scsilun_to_int(&req->lun));
1991
1992        if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
1993                shost_printk(KERN_ERR, target->scsi_host, PFX
1994                             "problems processing SRP_AER_REQ\n");
1995}
1996
1997static void srp_recv_done(struct ib_cq *cq, struct ib_wc *wc)
1998{
1999        struct srp_iu *iu = container_of(wc->wr_cqe, struct srp_iu, cqe);
2000        struct srp_rdma_ch *ch = cq->cq_context;
2001        struct srp_target_port *target = ch->target;
2002        struct ib_device *dev = target->srp_host->srp_dev->dev;
2003        int res;
2004        u8 opcode;
2005
2006        if (unlikely(wc->status != IB_WC_SUCCESS)) {
2007                srp_handle_qp_err(cq, wc, "RECV");
2008                return;
2009        }
2010
2011        ib_dma_sync_single_for_cpu(dev, iu->dma, ch->max_ti_iu_len,
2012                                   DMA_FROM_DEVICE);
2013
2014        opcode = *(u8 *) iu->buf;
2015
2016        if (0) {
2017                shost_printk(KERN_ERR, target->scsi_host,
2018                             PFX "recv completion, opcode 0x%02x\n", opcode);
2019                print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1,
2020                               iu->buf, wc->byte_len, true);
2021        }
2022
2023        switch (opcode) {
2024        case SRP_RSP:
2025                srp_process_rsp(ch, iu->buf);
2026                break;
2027
2028        case SRP_CRED_REQ:
2029                srp_process_cred_req(ch, iu->buf);
2030                break;
2031
2032        case SRP_AER_REQ:
2033                srp_process_aer_req(ch, iu->buf);
2034                break;
2035
2036        case SRP_T_LOGOUT:
2037                /* XXX Handle target logout */
2038                shost_printk(KERN_WARNING, target->scsi_host,
2039                             PFX "Got target logout request\n");
2040                break;
2041
2042        default:
2043                shost_printk(KERN_WARNING, target->scsi_host,
2044                             PFX "Unhandled SRP opcode 0x%02x\n", opcode);
2045                break;
2046        }
2047
2048        ib_dma_sync_single_for_device(dev, iu->dma, ch->max_ti_iu_len,
2049                                      DMA_FROM_DEVICE);
2050
2051        res = srp_post_recv(ch, iu);
2052        if (res != 0)
2053                shost_printk(KERN_ERR, target->scsi_host,
2054                             PFX "Recv failed with error code %d\n", res);
2055}
2056
2057/**
2058 * srp_tl_err_work() - handle a transport layer error
2059 * @work: Work structure embedded in an SRP target port.
2060 *
2061 * Note: This function may get invoked before the rport has been created,
2062 * hence the target->rport test.
2063 */
2064static void srp_tl_err_work(struct work_struct *work)
2065{
2066        struct srp_target_port *target;
2067
2068        target = container_of(work, struct srp_target_port, tl_err_work);
2069        if (target->rport)
2070                srp_start_tl_fail_timers(target->rport);
2071}
2072
2073static void srp_handle_qp_err(struct ib_cq *cq, struct ib_wc *wc,
2074                const char *opname)
2075{
2076        struct srp_rdma_ch *ch = cq->cq_context;
2077        struct srp_target_port *target = ch->target;
2078
2079        if (ch->connected && !target->qp_in_error) {
2080                shost_printk(KERN_ERR, target->scsi_host,
2081                             PFX "failed %s status %s (%d) for CQE %p\n",
2082                             opname, ib_wc_status_msg(wc->status), wc->status,
2083                             wc->wr_cqe);
2084                queue_work(system_long_wq, &target->tl_err_work);
2085        }
2086        target->qp_in_error = true;
2087}
2088
2089static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
2090{
2091        struct srp_target_port *target = host_to_target(shost);
2092        struct srp_rport *rport = target->rport;
2093        struct srp_rdma_ch *ch;
2094        struct srp_request *req;
2095        struct srp_iu *iu;
2096        struct srp_cmd *cmd;
2097        struct ib_device *dev;
2098        unsigned long flags;
2099        u32 tag;
2100        u16 idx;
2101        int len, ret;
2102        const bool in_scsi_eh = !in_interrupt() && current == shost->ehandler;
2103
2104        /*
2105         * The SCSI EH thread is the only context from which srp_queuecommand()
2106         * can get invoked for blocked devices (SDEV_BLOCK /
2107         * SDEV_CREATED_BLOCK). Avoid racing with srp_reconnect_rport() by
2108         * locking the rport mutex if invoked from inside the SCSI EH.
2109         */
2110        if (in_scsi_eh)
2111                mutex_lock(&rport->mutex);
2112
2113        scmnd->result = srp_chkready(target->rport);
2114        if (unlikely(scmnd->result))
2115                goto err;
2116
2117        WARN_ON_ONCE(scmnd->request->tag < 0);
2118        tag = blk_mq_unique_tag(scmnd->request);
2119        ch = &target->ch[blk_mq_unique_tag_to_hwq(tag)];
2120        idx = blk_mq_unique_tag_to_tag(tag);
2121        WARN_ONCE(idx >= target->req_ring_size, "%s: tag %#x: idx %d >= %d\n",
2122                  dev_name(&shost->shost_gendev), tag, idx,
2123                  target->req_ring_size);
2124
2125        spin_lock_irqsave(&ch->lock, flags);
2126        iu = __srp_get_tx_iu(ch, SRP_IU_CMD);
2127        spin_unlock_irqrestore(&ch->lock, flags);
2128
2129        if (!iu)
2130                goto err;
2131
2132        req = &ch->req_ring[idx];
2133        dev = target->srp_host->srp_dev->dev;
2134        ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_iu_len,
2135                                   DMA_TO_DEVICE);
2136
2137        scmnd->host_scribble = (void *) req;
2138
2139        cmd = iu->buf;
2140        memset(cmd, 0, sizeof *cmd);
2141
2142        cmd->opcode = SRP_CMD;
2143        int_to_scsilun(scmnd->device->lun, &cmd->lun);
2144        cmd->tag    = tag;
2145        memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
2146
2147        req->scmnd    = scmnd;
2148        req->cmd      = iu;
2149
2150        len = srp_map_data(scmnd, ch, req);
2151        if (len < 0) {
2152                shost_printk(KERN_ERR, target->scsi_host,
2153                             PFX "Failed to map data (%d)\n", len);
2154                /*
2155                 * If we ran out of memory descriptors (-ENOMEM) because an
2156                 * application is queuing many requests with more than
2157                 * max_pages_per_mr sg-list elements, tell the SCSI mid-layer
2158                 * to reduce queue depth temporarily.
2159                 */
2160                scmnd->result = len == -ENOMEM ?
2161                        DID_OK << 16 | QUEUE_FULL << 1 : DID_ERROR << 16;
2162                goto err_iu;
2163        }
2164
2165        ib_dma_sync_single_for_device(dev, iu->dma, target->max_iu_len,
2166                                      DMA_TO_DEVICE);
2167
2168        if (srp_post_send(ch, iu, len)) {
2169                shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n");
2170                goto err_unmap;
2171        }
2172
2173        ret = 0;
2174
2175unlock_rport:
2176        if (in_scsi_eh)
2177                mutex_unlock(&rport->mutex);
2178
2179        return ret;
2180
2181err_unmap:
2182        srp_unmap_data(scmnd, ch, req);
2183
2184err_iu:
2185        srp_put_tx_iu(ch, iu, SRP_IU_CMD);
2186
2187        /*
2188         * Avoid that the loops that iterate over the request ring can
2189         * encounter a dangling SCSI command pointer.
2190         */
2191        req->scmnd = NULL;
2192
2193err:
2194        if (scmnd->result) {
2195                scmnd->scsi_done(scmnd);
2196                ret = 0;
2197        } else {
2198                ret = SCSI_MLQUEUE_HOST_BUSY;
2199        }
2200
2201        goto unlock_rport;
2202}
2203
2204/*
2205 * Note: the resources allocated in this function are freed in
2206 * srp_free_ch_ib().
2207 */
2208static int srp_alloc_iu_bufs(struct srp_rdma_ch *ch)
2209{
2210        struct srp_target_port *target = ch->target;
2211        int i;
2212
2213        ch->rx_ring = kcalloc(target->queue_size, sizeof(*ch->rx_ring),
2214                              GFP_KERNEL);
2215        if (!ch->rx_ring)
2216                goto err_no_ring;
2217        ch->tx_ring = kcalloc(target->queue_size, sizeof(*ch->tx_ring),
2218                              GFP_KERNEL);
2219        if (!ch->tx_ring)
2220                goto err_no_ring;
2221
2222        for (i = 0; i < target->queue_size; ++i) {
2223                ch->rx_ring[i] = srp_alloc_iu(target->srp_host,
2224                                              ch->max_ti_iu_len,
2225                                              GFP_KERNEL, DMA_FROM_DEVICE);
2226                if (!ch->rx_ring[i])
2227                        goto err;
2228        }
2229
2230        for (i = 0; i < target->queue_size; ++i) {
2231                ch->tx_ring[i] = srp_alloc_iu(target->srp_host,
2232                                              target->max_iu_len,
2233                                              GFP_KERNEL, DMA_TO_DEVICE);
2234                if (!ch->tx_ring[i])
2235                        goto err;
2236
2237                list_add(&ch->tx_ring[i]->list, &ch->free_tx);
2238        }
2239
2240        return 0;
2241
2242err:
2243        for (i = 0; i < target->queue_size; ++i) {
2244                srp_free_iu(target->srp_host, ch->rx_ring[i]);
2245                srp_free_iu(target->srp_host, ch->tx_ring[i]);
2246        }
2247
2248
2249err_no_ring:
2250        kfree(ch->tx_ring);
2251        ch->tx_ring = NULL;
2252        kfree(ch->rx_ring);
2253        ch->rx_ring = NULL;
2254
2255        return -ENOMEM;
2256}
2257
2258static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask)
2259{
2260        uint64_t T_tr_ns, max_compl_time_ms;
2261        uint32_t rq_tmo_jiffies;
2262
2263        /*
2264         * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair,
2265         * table 91), both the QP timeout and the retry count have to be set
2266         * for RC QP's during the RTR to RTS transition.
2267         */
2268        WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) !=
2269                     (IB_QP_TIMEOUT | IB_QP_RETRY_CNT));
2270
2271        /*
2272         * Set target->rq_tmo_jiffies to one second more than the largest time
2273         * it can take before an error completion is generated. See also
2274         * C9-140..142 in the IBTA spec for more information about how to
2275         * convert the QP Local ACK Timeout value to nanoseconds.
2276         */
2277        T_tr_ns = 4096 * (1ULL << qp_attr->timeout);
2278        max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns;
2279        do_div(max_compl_time_ms, NSEC_PER_MSEC);
2280        rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000);
2281
2282        return rq_tmo_jiffies;
2283}
2284
2285static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
2286                               const struct srp_login_rsp *lrsp,
2287                               struct srp_rdma_ch *ch)
2288{
2289        struct srp_target_port *target = ch->target;
2290        struct ib_qp_attr *qp_attr = NULL;
2291        int attr_mask = 0;
2292        int ret;
2293        int i;
2294
2295        if (lrsp->opcode == SRP_LOGIN_RSP) {
2296                ch->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_len);
2297                ch->req_lim       = be32_to_cpu(lrsp->req_lim_delta);
2298
2299                /*
2300                 * Reserve credits for task management so we don't
2301                 * bounce requests back to the SCSI mid-layer.
2302                 */
2303                target->scsi_host->can_queue
2304                        = min(ch->req_lim - SRP_TSK_MGMT_SQ_SIZE,
2305                              target->scsi_host->can_queue);
2306                target->scsi_host->cmd_per_lun
2307                        = min_t(int, target->scsi_host->can_queue,
2308                                target->scsi_host->cmd_per_lun);
2309        } else {
2310                shost_printk(KERN_WARNING, target->scsi_host,
2311                             PFX "Unhandled RSP opcode %#x\n", lrsp->opcode);
2312                ret = -ECONNRESET;
2313                goto error;
2314        }
2315
2316        if (!ch->rx_ring) {
2317                ret = srp_alloc_iu_bufs(ch);
2318                if (ret)
2319                        goto error;
2320        }
2321
2322        ret = -ENOMEM;
2323        qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL);
2324        if (!qp_attr)
2325                goto error;
2326
2327        qp_attr->qp_state = IB_QPS_RTR;
2328        ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
2329        if (ret)
2330                goto error_free;
2331
2332        ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
2333        if (ret)
2334                goto error_free;
2335
2336        for (i = 0; i < target->queue_size; i++) {
2337                struct srp_iu *iu = ch->rx_ring[i];
2338
2339                ret = srp_post_recv(ch, iu);
2340                if (ret)
2341                        goto error_free;
2342        }
2343
2344        qp_attr->qp_state = IB_QPS_RTS;
2345        ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
2346        if (ret)
2347                goto error_free;
2348
2349        target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);
2350
2351        ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
2352        if (ret)
2353                goto error_free;
2354
2355        ret = ib_send_cm_rtu(cm_id, NULL, 0);
2356
2357error_free:
2358        kfree(qp_attr);
2359
2360error:
2361        ch->status = ret;
2362}
2363
2364static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
2365                               struct ib_cm_event *event,
2366                               struct srp_rdma_ch *ch)
2367{
2368        struct srp_target_port *target = ch->target;
2369        struct Scsi_Host *shost = target->scsi_host;
2370        struct ib_class_port_info *cpi;
2371        int opcode;
2372
2373        switch (event->param.rej_rcvd.reason) {
2374        case IB_CM_REJ_PORT_CM_REDIRECT:
2375                cpi = event->param.rej_rcvd.ari;
2376                ch->path.dlid = cpi->redirect_lid;
2377                ch->path.pkey = cpi->redirect_pkey;
2378                cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
2379                memcpy(ch->path.dgid.raw, cpi->redirect_gid, 16);
2380
2381                ch->status = ch->path.dlid ?
2382                        SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
2383                break;
2384
2385        case IB_CM_REJ_PORT_REDIRECT:
2386                if (srp_target_is_topspin(target)) {
2387                        /*
2388                         * Topspin/Cisco SRP gateways incorrectly send
2389                         * reject reason code 25 when they mean 24
2390                         * (port redirect).
2391                         */
2392                        memcpy(ch->path.dgid.raw,
2393                               event->param.rej_rcvd.ari, 16);
2394
2395                        shost_printk(KERN_DEBUG, shost,
2396                                     PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
2397                                     be64_to_cpu(ch->path.dgid.global.subnet_prefix),
2398                                     be64_to_cpu(ch->path.dgid.global.interface_id));
2399
2400                        ch->status = SRP_PORT_REDIRECT;
2401                } else {
2402                        shost_printk(KERN_WARNING, shost,
2403                                     "  REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
2404                        ch->status = -ECONNRESET;
2405                }
2406                break;
2407
2408        case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
2409                shost_printk(KERN_WARNING, shost,
2410                            "  REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n");
2411                ch->status = -ECONNRESET;
2412                break;
2413
2414        case IB_CM_REJ_CONSUMER_DEFINED:
2415                opcode = *(u8 *) event->private_data;
2416                if (opcode == SRP_LOGIN_REJ) {
2417                        struct srp_login_rej *rej = event->private_data;
2418                        u32 reason = be32_to_cpu(rej->reason);
2419
2420                        if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
2421                                shost_printk(KERN_WARNING, shost,
2422                                             PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
2423                        else
2424                                shost_printk(KERN_WARNING, shost, PFX
2425                                             "SRP LOGIN from %pI6 to %pI6 REJECTED, reason 0x%08x\n",
2426                                             target->sgid.raw,
2427                                             target->orig_dgid.raw, reason);
2428                } else
2429                        shost_printk(KERN_WARNING, shost,
2430                                     "  REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
2431                                     " opcode 0x%02x\n", opcode);
2432                ch->status = -ECONNRESET;
2433                break;
2434
2435        case IB_CM_REJ_STALE_CONN:
2436                shost_printk(KERN_WARNING, shost, "  REJ reason: stale connection\n");
2437                ch->status = SRP_STALE_CONN;
2438                break;
2439
2440        default:
2441                shost_printk(KERN_WARNING, shost, "  REJ reason 0x%x\n",
2442                             event->param.rej_rcvd.reason);
2443                ch->status = -ECONNRESET;
2444        }
2445}
2446
2447static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
2448{
2449        struct srp_rdma_ch *ch = cm_id->context;
2450        struct srp_target_port *target = ch->target;
2451        int comp = 0;
2452
2453        switch (event->event) {
2454        case IB_CM_REQ_ERROR:
2455                shost_printk(KERN_DEBUG, target->scsi_host,
2456                             PFX "Sending CM REQ failed\n");
2457                comp = 1;
2458                ch->status = -ECONNRESET;
2459                break;
2460
2461        case IB_CM_REP_RECEIVED:
2462                comp = 1;
2463                srp_cm_rep_handler(cm_id, event->private_data, ch);
2464                break;
2465
2466        case IB_CM_REJ_RECEIVED:
2467                shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
2468                comp = 1;
2469
2470                srp_cm_rej_handler(cm_id, event, ch);
2471                break;
2472
2473        case IB_CM_DREQ_RECEIVED:
2474                shost_printk(KERN_WARNING, target->scsi_host,
2475                             PFX "DREQ received - connection closed\n");
2476                ch->connected = false;
2477                if (ib_send_cm_drep(cm_id, NULL, 0))
2478                        shost_printk(KERN_ERR, target->scsi_host,
2479                                     PFX "Sending CM DREP failed\n");
2480                queue_work(system_long_wq, &target->tl_err_work);
2481                break;
2482
2483        case IB_CM_TIMEWAIT_EXIT:
2484                shost_printk(KERN_ERR, target->scsi_host,
2485                             PFX "connection closed\n");
2486                comp = 1;
2487
2488                ch->status = 0;
2489                break;
2490
2491        case IB_CM_MRA_RECEIVED:
2492        case IB_CM_DREQ_ERROR:
2493        case IB_CM_DREP_RECEIVED:
2494                break;
2495
2496        default:
2497                shost_printk(KERN_WARNING, target->scsi_host,
2498                             PFX "Unhandled CM event %d\n", event->event);
2499                break;
2500        }
2501
2502        if (comp)
2503                complete(&ch->done);
2504
2505        return 0;
2506}
2507
2508/**
2509 * srp_change_queue_depth - setting device queue depth
2510 * @sdev: scsi device struct
2511 * @qdepth: requested queue depth
2512 *
2513 * Returns queue depth.
2514 */
2515static int
2516srp_change_queue_depth(struct scsi_device *sdev, int qdepth)
2517{
2518        if (!sdev->tagged_supported)
2519                qdepth = 1;
2520        return scsi_change_queue_depth(sdev, qdepth);
2521}
2522
2523static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag, u64 lun,
2524                             u8 func, u8 *status)
2525{
2526        struct srp_target_port *target = ch->target;
2527        struct srp_rport *rport = target->rport;
2528        struct ib_device *dev = target->srp_host->srp_dev->dev;
2529        struct srp_iu *iu;
2530        struct srp_tsk_mgmt *tsk_mgmt;
2531        int res;
2532
2533        if (!ch->connected || target->qp_in_error)
2534                return -1;
2535
2536        /*
2537         * Lock the rport mutex to avoid that srp_create_ch_ib() is
2538         * invoked while a task management function is being sent.
2539         */
2540        mutex_lock(&rport->mutex);
2541        spin_lock_irq(&ch->lock);
2542        iu = __srp_get_tx_iu(ch, SRP_IU_TSK_MGMT);
2543        spin_unlock_irq(&ch->lock);
2544
2545        if (!iu) {
2546                mutex_unlock(&rport->mutex);
2547
2548                return -1;
2549        }
2550
2551        ib_dma_sync_single_for_cpu(dev, iu->dma, sizeof *tsk_mgmt,
2552                                   DMA_TO_DEVICE);
2553        tsk_mgmt = iu->buf;
2554        memset(tsk_mgmt, 0, sizeof *tsk_mgmt);
2555
2556        tsk_mgmt->opcode        = SRP_TSK_MGMT;
2557        int_to_scsilun(lun, &tsk_mgmt->lun);
2558        tsk_mgmt->tsk_mgmt_func = func;
2559        tsk_mgmt->task_tag      = req_tag;
2560
2561        spin_lock_irq(&ch->lock);
2562        ch->tsk_mgmt_tag = (ch->tsk_mgmt_tag + 1) | SRP_TAG_TSK_MGMT;
2563        tsk_mgmt->tag = ch->tsk_mgmt_tag;
2564        spin_unlock_irq(&ch->lock);
2565
2566        init_completion(&ch->tsk_mgmt_done);
2567
2568        ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt,
2569                                      DMA_TO_DEVICE);
2570        if (srp_post_send(ch, iu, sizeof(*tsk_mgmt))) {
2571                srp_put_tx_iu(ch, iu, SRP_IU_TSK_MGMT);
2572                mutex_unlock(&rport->mutex);
2573
2574                return -1;
2575        }
2576        res = wait_for_completion_timeout(&ch->tsk_mgmt_done,
2577                                        msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS));
2578        if (res > 0 && status)
2579                *status = ch->tsk_mgmt_status;
2580        mutex_unlock(&rport->mutex);
2581
2582        WARN_ON_ONCE(res < 0);
2583
2584        return res > 0 ? 0 : -1;
2585}
2586
2587static int srp_abort(struct scsi_cmnd *scmnd)
2588{
2589        struct srp_target_port *target = host_to_target(scmnd->device->host);
2590        struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
2591        u32 tag;
2592        u16 ch_idx;
2593        struct srp_rdma_ch *ch;
2594        int ret;
2595
2596        shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
2597
2598        if (!req)
2599                return SUCCESS;
2600        tag = blk_mq_unique_tag(scmnd->request);
2601        ch_idx = blk_mq_unique_tag_to_hwq(tag);
2602        if (WARN_ON_ONCE(ch_idx >= target->ch_count))
2603                return SUCCESS;
2604        ch = &target->ch[ch_idx];
2605        if (!srp_claim_req(ch, req, NULL, scmnd))
2606                return SUCCESS;
2607        shost_printk(KERN_ERR, target->scsi_host,
2608                     "Sending SRP abort for tag %#x\n", tag);
2609        if (srp_send_tsk_mgmt(ch, tag, scmnd->device->lun,
2610                              SRP_TSK_ABORT_TASK, NULL) == 0)
2611                ret = SUCCESS;
2612        else if (target->rport->state == SRP_RPORT_LOST)
2613                ret = FAST_IO_FAIL;
2614        else
2615                ret = FAILED;
2616        srp_free_req(ch, req, scmnd, 0);
2617        scmnd->result = DID_ABORT << 16;
2618        scmnd->scsi_done(scmnd);
2619
2620        return ret;
2621}
2622
2623static int srp_reset_device(struct scsi_cmnd *scmnd)
2624{
2625        struct srp_target_port *target = host_to_target(scmnd->device->host);
2626        struct srp_rdma_ch *ch;
2627        int i;
2628        u8 status;
2629
2630        shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
2631
2632        ch = &target->ch[0];
2633        if (srp_send_tsk_mgmt(ch, SRP_TAG_NO_REQ, scmnd->device->lun,
2634                              SRP_TSK_LUN_RESET, &status))
2635                return FAILED;
2636        if (status)
2637                return FAILED;
2638
2639        for (i = 0; i < target->ch_count; i++) {
2640                ch = &target->ch[i];
2641                for (i = 0; i < target->req_ring_size; ++i) {
2642                        struct srp_request *req = &ch->req_ring[i];
2643
2644                        srp_finish_req(ch, req, scmnd->device, DID_RESET << 16);
2645                }
2646        }
2647
2648        return SUCCESS;
2649}
2650
2651static int srp_reset_host(struct scsi_cmnd *scmnd)
2652{
2653        struct srp_target_port *target = host_to_target(scmnd->device->host);
2654
2655        shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n");
2656
2657        return srp_reconnect_rport(target->rport) == 0 ? SUCCESS : FAILED;
2658}
2659
2660static int srp_slave_alloc(struct scsi_device *sdev)
2661{
2662        struct Scsi_Host *shost = sdev->host;
2663        struct srp_target_port *target = host_to_target(shost);
2664        struct srp_device *srp_dev = target->srp_host->srp_dev;
2665
2666        if (true)
2667                blk_queue_virt_boundary(sdev->request_queue,
2668                                        ~srp_dev->mr_page_mask);
2669
2670        return 0;
2671}
2672
2673static int srp_slave_configure(struct scsi_device *sdev)
2674{
2675        struct Scsi_Host *shost = sdev->host;
2676        struct srp_target_port *target = host_to_target(shost);
2677        struct request_queue *q = sdev->request_queue;
2678        unsigned long timeout;
2679
2680        if (sdev->type == TYPE_DISK) {
2681                timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies);
2682                blk_queue_rq_timeout(q, timeout);
2683        }
2684
2685        return 0;
2686}
2687
2688static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
2689                           char *buf)
2690{
2691        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2692
2693        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->id_ext));
2694}
2695
2696static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
2697                             char *buf)
2698{
2699        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2700
2701        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->ioc_guid));
2702}
2703
2704static ssize_t show_service_id(struct device *dev,
2705                               struct device_attribute *attr, char *buf)
2706{
2707        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2708
2709        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->service_id));
2710}
2711
2712static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
2713                         char *buf)
2714{
2715        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2716
2717        return sprintf(buf, "0x%04x\n", be16_to_cpu(target->pkey));
2718}
2719
2720static ssize_t show_sgid(struct device *dev, struct device_attribute *attr,
2721                         char *buf)
2722{
2723        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2724
2725        return sprintf(buf, "%pI6\n", target->sgid.raw);
2726}
2727
2728static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
2729                         char *buf)
2730{
2731        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2732        struct srp_rdma_ch *ch = &target->ch[0];
2733
2734        return sprintf(buf, "%pI6\n", ch->path.dgid.raw);
2735}
2736
2737static ssize_t show_orig_dgid(struct device *dev,
2738                              struct device_attribute *attr, char *buf)
2739{
2740        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2741
2742        return sprintf(buf, "%pI6\n", target->orig_dgid.raw);
2743}
2744
2745static ssize_t show_req_lim(struct device *dev,
2746                            struct device_attribute *attr, char *buf)
2747{
2748        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2749        struct srp_rdma_ch *ch;
2750        int i, req_lim = INT_MAX;
2751
2752        for (i = 0; i < target->ch_count; i++) {
2753                ch = &target->ch[i];
2754                req_lim = min(req_lim, ch->req_lim);
2755        }
2756        return sprintf(buf, "%d\n", req_lim);
2757}
2758
2759static ssize_t show_zero_req_lim(struct device *dev,
2760                                 struct device_attribute *attr, char *buf)
2761{
2762        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2763
2764        return sprintf(buf, "%d\n", target->zero_req_lim);
2765}
2766
2767static ssize_t show_local_ib_port(struct device *dev,
2768                                  struct device_attribute *attr, char *buf)
2769{
2770        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2771
2772        return sprintf(buf, "%d\n", target->srp_host->port);
2773}
2774
2775static ssize_t show_local_ib_device(struct device *dev,
2776                                    struct device_attribute *attr, char *buf)
2777{
2778        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2779
2780        return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
2781}
2782
2783static ssize_t show_ch_count(struct device *dev, struct device_attribute *attr,
2784                             char *buf)
2785{
2786        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2787
2788        return sprintf(buf, "%d\n", target->ch_count);
2789}
2790
2791static ssize_t show_comp_vector(struct device *dev,
2792                                struct device_attribute *attr, char *buf)
2793{
2794        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2795
2796        return sprintf(buf, "%d\n", target->comp_vector);
2797}
2798
2799static ssize_t show_tl_retry_count(struct device *dev,
2800                                   struct device_attribute *attr, char *buf)
2801{
2802        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2803
2804        return sprintf(buf, "%d\n", target->tl_retry_count);
2805}
2806
2807static ssize_t show_cmd_sg_entries(struct device *dev,
2808                                   struct device_attribute *attr, char *buf)
2809{
2810        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2811
2812        return sprintf(buf, "%u\n", target->cmd_sg_cnt);
2813}
2814
2815static ssize_t show_allow_ext_sg(struct device *dev,
2816                                 struct device_attribute *attr, char *buf)
2817{
2818        struct srp_target_port *target = host_to_target(class_to_shost(dev));
2819
2820        return sprintf(buf, "%s\n", target->allow_ext_sg ? "true" : "false");
2821}
2822
2823static DEVICE_ATTR(id_ext,          S_IRUGO, show_id_ext,          NULL);
2824static DEVICE_ATTR(ioc_guid,        S_IRUGO, show_ioc_guid,        NULL);
2825static DEVICE_ATTR(service_id,      S_IRUGO, show_service_id,      NULL);
2826static DEVICE_ATTR(pkey,            S_IRUGO, show_pkey,            NULL);
2827static DEVICE_ATTR(sgid,            S_IRUGO, show_sgid,            NULL);
2828static DEVICE_ATTR(dgid,            S_IRUGO, show_dgid,            NULL);
2829static DEVICE_ATTR(orig_dgid,       S_IRUGO, show_orig_dgid,       NULL);
2830static DEVICE_ATTR(req_lim,         S_IRUGO, show_req_lim,         NULL);
2831static DEVICE_ATTR(zero_req_lim,    S_IRUGO, show_zero_req_lim,    NULL);
2832static DEVICE_ATTR(local_ib_port,   S_IRUGO, show_local_ib_port,   NULL);
2833static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
2834static DEVICE_ATTR(ch_count,        S_IRUGO, show_ch_count,        NULL);
2835static DEVICE_ATTR(comp_vector,     S_IRUGO, show_comp_vector,     NULL);
2836static DEVICE_ATTR(tl_retry_count,  S_IRUGO, show_tl_retry_count,  NULL);
2837static DEVICE_ATTR(cmd_sg_entries,  S_IRUGO, show_cmd_sg_entries,  NULL);
2838static DEVICE_ATTR(allow_ext_sg,    S_IRUGO, show_allow_ext_sg,    NULL);
2839
2840static struct device_attribute *srp_host_attrs[] = {
2841        &dev_attr_id_ext,
2842        &dev_attr_ioc_guid,
2843        &dev_attr_service_id,
2844        &dev_attr_pkey,
2845        &dev_attr_sgid,
2846        &dev_attr_dgid,
2847        &dev_attr_orig_dgid,
2848        &dev_attr_req_lim,
2849        &dev_attr_zero_req_lim,
2850        &dev_attr_local_ib_port,
2851        &dev_attr_local_ib_device,
2852        &dev_attr_ch_count,
2853        &dev_attr_comp_vector,
2854        &dev_attr_tl_retry_count,
2855        &dev_attr_cmd_sg_entries,
2856        &dev_attr_allow_ext_sg,
2857        NULL
2858};
2859
2860static struct scsi_host_template srp_template = {
2861        .module                         = THIS_MODULE,
2862        .name                           = "InfiniBand SRP initiator",
2863        .proc_name                      = DRV_NAME,
2864        .slave_alloc                    = srp_slave_alloc,
2865        .slave_configure                = srp_slave_configure,
2866        .info                           = srp_target_info,
2867        .queuecommand                   = srp_queuecommand,
2868        .change_queue_depth             = srp_change_queue_depth,
2869        .eh_abort_handler               = srp_abort,
2870        .eh_device_reset_handler        = srp_reset_device,
2871        .eh_host_reset_handler          = srp_reset_host,
2872        .skip_settle_delay              = true,
2873        .sg_tablesize                   = SRP_DEF_SG_TABLESIZE,
2874        .can_queue                      = SRP_DEFAULT_CMD_SQ_SIZE,
2875        .this_id                        = -1,
2876        .cmd_per_lun                    = SRP_DEFAULT_CMD_SQ_SIZE,
2877        .use_clustering                 = ENABLE_CLUSTERING,
2878        .shost_attrs                    = srp_host_attrs,
2879        .track_queue_depth              = 1,
2880};
2881
2882static int srp_sdev_count(struct Scsi_Host *host)
2883{
2884        struct scsi_device *sdev;
2885        int c = 0;
2886
2887        shost_for_each_device(sdev, host)
2888                c++;
2889
2890        return c;
2891}
2892
2893/*
2894 * Return values:
2895 * < 0 upon failure. Caller is responsible for SRP target port cleanup.
2896 * 0 and target->state == SRP_TARGET_REMOVED if asynchronous target port
2897 *    removal has been scheduled.
2898 * 0 and target->state != SRP_TARGET_REMOVED upon success.
2899 */
2900static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
2901{
2902        struct srp_rport_identifiers ids;
2903        struct srp_rport *rport;
2904
2905        target->state = SRP_TARGET_SCANNING;
2906        sprintf(target->target_name, "SRP.T10:%016llX",
2907                be64_to_cpu(target->id_ext));
2908
2909        if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
2910                return -ENODEV;
2911
2912        memcpy(ids.port_id, &target->id_ext, 8);
2913        memcpy(ids.port_id + 8, &target->ioc_guid, 8);
2914        ids.roles = SRP_RPORT_ROLE_TARGET;
2915        rport = srp_rport_add(target->scsi_host, &ids);
2916        if (IS_ERR(rport)) {
2917                scsi_remove_host(target->scsi_host);
2918                return PTR_ERR(rport);
2919        }
2920
2921        rport->lld_data = target;
2922        target->rport = rport;
2923
2924        spin_lock(&host->target_lock);
2925        list_add_tail(&target->list, &host->target_list);
2926        spin_unlock(&host->target_lock);
2927
2928        scsi_scan_target(&target->scsi_host->shost_gendev,
2929                         0, target->scsi_id, SCAN_WILD_CARD, SCSI_SCAN_INITIAL);
2930
2931        if (srp_connected_ch(target) < target->ch_count ||
2932            target->qp_in_error) {
2933                shost_printk(KERN_INFO, target->scsi_host,
2934                             PFX "SCSI scan failed - removing SCSI host\n");
2935                srp_queue_remove_work(target);
2936                goto out;
2937        }
2938
2939        pr_debug("%s: SCSI scan succeeded - detected %d LUNs\n",
2940                 dev_name(&target->scsi_host->shost_gendev),
2941                 srp_sdev_count(target->scsi_host));
2942
2943        spin_lock_irq(&target->lock);
2944        if (target->state == SRP_TARGET_SCANNING)
2945                target->state = SRP_TARGET_LIVE;
2946        spin_unlock_irq(&target->lock);
2947
2948out:
2949        return 0;
2950}
2951
2952static void srp_release_dev(struct device *dev)
2953{
2954        struct srp_host *host =
2955                container_of(dev, struct srp_host, dev);
2956
2957        complete(&host->released);
2958}
2959
2960static struct class srp_class = {
2961        .name    = "infiniband_srp",
2962        .dev_release = srp_release_dev
2963};
2964
2965/**
2966 * srp_conn_unique() - check whether the connection to a target is unique
2967 * @host:   SRP host.
2968 * @target: SRP target port.
2969 */
2970static bool srp_conn_unique(struct srp_host *host,
2971                            struct srp_target_port *target)
2972{
2973        struct srp_target_port *t;
2974        bool ret = false;
2975
2976        if (target->state == SRP_TARGET_REMOVED)
2977                goto out;
2978
2979        ret = true;
2980
2981        spin_lock(&host->target_lock);
2982        list_for_each_entry(t, &host->target_list, list) {
2983                if (t != target &&
2984                    target->id_ext == t->id_ext &&
2985                    target->ioc_guid == t->ioc_guid &&
2986                    target->initiator_ext == t->initiator_ext) {
2987                        ret = false;
2988                        break;
2989                }
2990        }
2991        spin_unlock(&host->target_lock);
2992
2993out:
2994        return ret;
2995}
2996
2997/*
2998 * Target ports are added by writing
2999 *
3000 *     id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>,
3001 *     pkey=<P_Key>,service_id=<service ID>
3002 *
3003 * to the add_target sysfs attribute.
3004 */
3005enum {
3006        SRP_OPT_ERR             = 0,
3007        SRP_OPT_ID_EXT          = 1 << 0,
3008        SRP_OPT_IOC_GUID        = 1 << 1,
3009        SRP_OPT_DGID            = 1 << 2,
3010        SRP_OPT_PKEY            = 1 << 3,
3011        SRP_OPT_SERVICE_ID      = 1 << 4,
3012        SRP_OPT_MAX_SECT        = 1 << 5,
3013        SRP_OPT_MAX_CMD_PER_LUN = 1 << 6,
3014        SRP_OPT_IO_CLASS        = 1 << 7,
3015        SRP_OPT_INITIATOR_EXT   = 1 << 8,
3016        SRP_OPT_CMD_SG_ENTRIES  = 1 << 9,
3017        SRP_OPT_ALLOW_EXT_SG    = 1 << 10,
3018        SRP_OPT_SG_TABLESIZE    = 1 << 11,
3019        SRP_OPT_COMP_VECTOR     = 1 << 12,
3020        SRP_OPT_TL_RETRY_COUNT  = 1 << 13,
3021        SRP_OPT_QUEUE_SIZE      = 1 << 14,
3022        SRP_OPT_ALL             = (SRP_OPT_ID_EXT       |
3023                                   SRP_OPT_IOC_GUID     |
3024                                   SRP_OPT_DGID         |
3025                                   SRP_OPT_PKEY         |
3026                                   SRP_OPT_SERVICE_ID),
3027};
3028
3029static const match_table_t srp_opt_tokens = {
3030        { SRP_OPT_ID_EXT,               "id_ext=%s"             },
3031        { SRP_OPT_IOC_GUID,             "ioc_guid=%s"           },
3032        { SRP_OPT_DGID,                 "dgid=%s"               },
3033        { SRP_OPT_PKEY,                 "pkey=%x"               },
3034        { SRP_OPT_SERVICE_ID,           "service_id=%s"         },
3035        { SRP_OPT_MAX_SECT,             "max_sect=%d"           },
3036        { SRP_OPT_MAX_CMD_PER_LUN,      "max_cmd_per_lun=%d"    },
3037        { SRP_OPT_IO_CLASS,             "io_class=%x"           },
3038        { SRP_OPT_INITIATOR_EXT,        "initiator_ext=%s"      },
3039        { SRP_OPT_CMD_SG_ENTRIES,       "cmd_sg_entries=%u"     },
3040        { SRP_OPT_ALLOW_EXT_SG,         "allow_ext_sg=%u"       },
3041        { SRP_OPT_SG_TABLESIZE,         "sg_tablesize=%u"       },
3042        { SRP_OPT_COMP_VECTOR,          "comp_vector=%u"        },
3043        { SRP_OPT_TL_RETRY_COUNT,       "tl_retry_count=%u"     },
3044        { SRP_OPT_QUEUE_SIZE,           "queue_size=%d"         },
3045        { SRP_OPT_ERR,                  NULL                    }
3046};
3047
3048static int srp_parse_options(const char *buf, struct srp_target_port *target)
3049{
3050        char *options, *sep_opt;
3051        char *p;
3052        char dgid[3];
3053        substring_t args[MAX_OPT_ARGS];
3054        int opt_mask = 0;
3055        int token;
3056        int ret = -EINVAL;
3057        int i;
3058
3059        options = kstrdup(buf, GFP_KERNEL);
3060        if (!options)
3061                return -ENOMEM;
3062
3063        sep_opt = options;
3064        while ((p = strsep(&sep_opt, ",\n")) != NULL) {
3065                if (!*p)
3066                        continue;
3067
3068                token = match_token(p, srp_opt_tokens, args);
3069                opt_mask |= token;
3070
3071                switch (token) {
3072                case SRP_OPT_ID_EXT:
3073                        p = match_strdup(args);
3074                        if (!p) {
3075                                ret = -ENOMEM;
3076                                goto out;
3077                        }
3078                        target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
3079                        kfree(p);
3080                        break;
3081
3082                case SRP_OPT_IOC_GUID:
3083                        p = match_strdup(args);
3084                        if (!p) {
3085                                ret = -ENOMEM;
3086                                goto out;
3087                        }
3088                        target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16));
3089                        kfree(p);
3090                        break;
3091
3092                case SRP_OPT_DGID:
3093                        p = match_strdup(args);
3094                        if (!p) {
3095                                ret = -ENOMEM;
3096                                goto out;
3097                        }
3098                        if (strlen(p) != 32) {
3099                                pr_warn("bad dest GID parameter '%s'\n", p);
3100                                kfree(p);
3101                                goto out;
3102                        }
3103
3104                        for (i = 0; i < 16; ++i) {
3105                                strlcpy(dgid, p + i * 2, sizeof(dgid));
3106                                if (sscanf(dgid, "%hhx",
3107                                           &target->orig_dgid.raw[i]) < 1) {
3108                                        ret = -EINVAL;
3109                                        kfree(p);
3110                                        goto out;
3111                                }
3112                        }
3113                        kfree(p);
3114                        break;
3115
3116                case SRP_OPT_PKEY:
3117                        if (match_hex(args, &token)) {
3118                                pr_warn("bad P_Key parameter '%s'\n", p);
3119                                goto out;
3120                        }
3121                        target->pkey = cpu_to_be16(token);
3122                        break;
3123
3124                case SRP_OPT_SERVICE_ID:
3125                        p = match_strdup(args);
3126                        if (!p) {
3127                                ret = -ENOMEM;
3128                                goto out;
3129                        }
3130                        target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16));
3131                        kfree(p);
3132                        break;
3133
3134                case SRP_OPT_MAX_SECT:
3135                        if (match_int(args, &token)) {
3136                                pr_warn("bad max sect parameter '%s'\n", p);
3137                                goto out;
3138                        }
3139                        target->scsi_host->max_sectors = token;
3140                        break;
3141
3142                case SRP_OPT_QUEUE_SIZE:
3143                        if (match_int(args, &token) || token < 1) {
3144                                pr_warn("bad queue_size parameter '%s'\n", p);
3145                                goto out;
3146                        }
3147                        target->scsi_host->can_queue = token;
3148                        target->queue_size = token + SRP_RSP_SQ_SIZE +
3149                                             SRP_TSK_MGMT_SQ_SIZE;
3150                        if (!(opt_mask & SRP_OPT_MAX_CMD_PER_LUN))
3151                                target->scsi_host->cmd_per_lun = token;
3152                        break;
3153
3154                case SRP_OPT_MAX_CMD_PER_LUN:
3155                        if (match_int(args, &token) || token < 1) {
3156                                pr_warn("bad max cmd_per_lun parameter '%s'\n",
3157                                        p);
3158                                goto out;
3159                        }
3160                        target->scsi_host->cmd_per_lun = token;
3161                        break;
3162
3163                case SRP_OPT_IO_CLASS:
3164                        if (match_hex(args, &token)) {
3165                                pr_warn("bad IO class parameter '%s'\n", p);
3166                                goto out;
3167                        }
3168                        if (token != SRP_REV10_IB_IO_CLASS &&
3169                            token != SRP_REV16A_IB_IO_CLASS) {
3170                                pr_warn("unknown IO class parameter value %x specified (use %x or %x).\n",
3171                                        token, SRP_REV10_IB_IO_CLASS,
3172                                        SRP_REV16A_IB_IO_CLASS);
3173                                goto out;
3174                        }
3175                        target->io_class = token;
3176                        break;
3177
3178                case SRP_OPT_INITIATOR_EXT:
3179                        p = match_strdup(args);
3180                        if (!p) {
3181                                ret = -ENOMEM;
3182                                goto out;
3183                        }
3184                        target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
3185                        kfree(p);
3186                        break;
3187
3188                case SRP_OPT_CMD_SG_ENTRIES:
3189                        if (match_int(args, &token) || token < 1 || token > 255) {
3190                                pr_warn("bad max cmd_sg_entries parameter '%s'\n",
3191                                        p);
3192                                goto out;
3193                        }
3194                        target->cmd_sg_cnt = token;
3195                        break;
3196
3197                case SRP_OPT_ALLOW_EXT_SG:
3198                        if (match_int(args, &token)) {
3199                                pr_warn("bad allow_ext_sg parameter '%s'\n", p);
3200                                goto out;
3201                        }
3202                        target->allow_ext_sg = !!token;
3203                        break;
3204
3205                case SRP_OPT_SG_TABLESIZE:
3206                        if (match_int(args, &token) || token < 1 ||
3207                                        token > SG_MAX_SEGMENTS) {
3208                                pr_warn("bad max sg_tablesize parameter '%s'\n",
3209                                        p);
3210                                goto out;
3211                        }
3212                        target->sg_tablesize = token;
3213                        break;
3214
3215                case SRP_OPT_COMP_VECTOR:
3216                        if (match_int(args, &token) || token < 0) {
3217                                pr_warn("bad comp_vector parameter '%s'\n", p);
3218                                goto out;
3219                        }
3220                        target->comp_vector = token;
3221                        break;
3222
3223                case SRP_OPT_TL_RETRY_COUNT:
3224                        if (match_int(args, &token) || token < 2 || token > 7) {
3225                                pr_warn("bad tl_retry_count parameter '%s' (must be a number between 2 and 7)\n",
3226                                        p);
3227                                goto out;
3228                        }
3229                        target->tl_retry_count = token;
3230                        break;
3231
3232                default:
3233                        pr_warn("unknown parameter or missing value '%s' in target creation request\n",
3234                                p);
3235                        goto out;
3236                }
3237        }
3238
3239        if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL)
3240                ret = 0;
3241        else
3242                for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
3243                        if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
3244                            !(srp_opt_tokens[i].token & opt_mask))
3245                                pr_warn("target creation request is missing parameter '%s'\n",
3246                                        srp_opt_tokens[i].pattern);
3247
3248        if (target->scsi_host->cmd_per_lun > target->scsi_host->can_queue
3249            && (opt_mask & SRP_OPT_MAX_CMD_PER_LUN))
3250                pr_warn("cmd_per_lun = %d > queue_size = %d\n",
3251                        target->scsi_host->cmd_per_lun,
3252                        target->scsi_host->can_queue);
3253
3254out:
3255        kfree(options);
3256        return ret;
3257}
3258
3259static ssize_t srp_create_target(struct device *dev,
3260                                 struct device_attribute *attr,
3261                                 const char *buf, size_t count)
3262{
3263        struct srp_host *host =
3264                container_of(dev, struct srp_host, dev);
3265        struct Scsi_Host *target_host;
3266        struct srp_target_port *target;
3267        struct srp_rdma_ch *ch;
3268        struct srp_device *srp_dev = host->srp_dev;
3269        struct ib_device *ibdev = srp_dev->dev;
3270        int ret, node_idx, node, cpu, i;
3271        unsigned int max_sectors_per_mr, mr_per_cmd = 0;
3272        bool multich = false;
3273
3274        target_host = scsi_host_alloc(&srp_template,
3275                                      sizeof (struct srp_target_port));
3276        if (!target_host)
3277                return -ENOMEM;
3278
3279        target_host->transportt  = ib_srp_transport_template;
3280        target_host->max_channel = 0;
3281        target_host->max_id      = 1;
3282        target_host->max_lun     = -1LL;
3283        target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb;
3284
3285        target = host_to_target(target_host);
3286
3287        target->io_class        = SRP_REV16A_IB_IO_CLASS;
3288        target->scsi_host       = target_host;
3289        target->srp_host        = host;
3290        target->pd              = host->srp_dev->pd;
3291        target->lkey            = host->srp_dev->pd->local_dma_lkey;
3292        target->cmd_sg_cnt      = cmd_sg_entries;
3293        target->sg_tablesize    = indirect_sg_entries ? : cmd_sg_entries;
3294        target->allow_ext_sg    = allow_ext_sg;
3295        target->tl_retry_count  = 7;
3296        target->queue_size      = SRP_DEFAULT_QUEUE_SIZE;
3297
3298        /*
3299         * Avoid that the SCSI host can be removed by srp_remove_target()
3300         * before this function returns.
3301         */
3302        scsi_host_get(target->scsi_host);
3303
3304        mutex_lock(&host->add_target_mutex);
3305
3306        ret = srp_parse_options(buf, target);
3307        if (ret)
3308                goto out;
3309
3310        target->req_ring_size = target->queue_size - SRP_TSK_MGMT_SQ_SIZE;
3311
3312        if (!srp_conn_unique(target->srp_host, target)) {
3313                shost_printk(KERN_INFO, target->scsi_host,
3314                             PFX "Already connected to target port with id_ext=%016llx;ioc_guid=%016llx;initiator_ext=%016llx\n",
3315                             be64_to_cpu(target->id_ext),
3316                             be64_to_cpu(target->ioc_guid),
3317                             be64_to_cpu(target->initiator_ext));
3318                ret = -EEXIST;
3319                goto out;
3320        }
3321
3322        if (!srp_dev->has_fmr && !srp_dev->has_fr && !target->allow_ext_sg &&
3323            target->cmd_sg_cnt < target->sg_tablesize) {
3324                pr_warn("No MR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
3325                target->sg_tablesize = target->cmd_sg_cnt;
3326        }
3327
3328        if (srp_dev->use_fast_reg || srp_dev->use_fmr) {
3329                /*
3330                 * FR and FMR can only map one HCA page per entry. If the
3331                 * start address is not aligned on a HCA page boundary two
3332                 * entries will be used for the head and the tail although
3333                 * these two entries combined contain at most one HCA page of
3334                 * data. Hence the "+ 1" in the calculation below.
3335                 *
3336                 * The indirect data buffer descriptor is contiguous so the
3337                 * memory for that buffer will only be registered if
3338                 * register_always is true. Hence add one to mr_per_cmd if
3339                 * register_always has been set.
3340                 */
3341                max_sectors_per_mr = srp_dev->max_pages_per_mr <<
3342                                  (ilog2(srp_dev->mr_page_size) - 9);
3343                mr_per_cmd = register_always +
3344                        (target->scsi_host->max_sectors + 1 +
3345                         max_sectors_per_mr - 1) / max_sectors_per_mr;
3346                pr_debug("max_sectors = %u; max_pages_per_mr = %u; mr_page_size = %u; max_sectors_per_mr = %u; mr_per_cmd = %u\n",
3347                         target->scsi_host->max_sectors,
3348                         srp_dev->max_pages_per_mr, srp_dev->mr_page_size,
3349                         max_sectors_per_mr, mr_per_cmd);
3350        }
3351
3352        target_host->sg_tablesize = target->sg_tablesize;
3353        target->mr_pool_size = target->scsi_host->can_queue * mr_per_cmd;
3354        target->mr_per_cmd = mr_per_cmd;
3355        target->indirect_size = target->sg_tablesize *
3356                                sizeof (struct srp_direct_buf);
3357        target->max_iu_len = sizeof (struct srp_cmd) +
3358                             sizeof (struct srp_indirect_buf) +
3359                             target->cmd_sg_cnt * sizeof (struct srp_direct_buf);
3360
3361        INIT_WORK(&target->tl_err_work, srp_tl_err_work);
3362        INIT_WORK(&target->remove_work, srp_remove_work);
3363        spin_lock_init(&target->lock);
3364        ret = ib_query_gid(ibdev, host->port, 0, &target->sgid, NULL);
3365        if (ret)
3366                goto out;
3367
3368        ret = -ENOMEM;
3369        target->ch_count = max_t(unsigned, num_online_nodes(),
3370                                 min(ch_count ? :
3371                                     min(4 * num_online_nodes(),
3372                                         ibdev->num_comp_vectors),
3373                                     num_online_cpus()));
3374        target->ch = kcalloc(target->ch_count, sizeof(*target->ch),
3375                             GFP_KERNEL);
3376        if (!target->ch)
3377                goto out;
3378
3379        node_idx = 0;
3380        for_each_online_node(node) {
3381                const int ch_start = (node_idx * target->ch_count /
3382                                      num_online_nodes());
3383                const int ch_end = ((node_idx + 1) * target->ch_count /
3384                                    num_online_nodes());
3385                const int cv_start = (node_idx * ibdev->num_comp_vectors /
3386                                      num_online_nodes() + target->comp_vector)
3387                                     % ibdev->num_comp_vectors;
3388                const int cv_end = ((node_idx + 1) * ibdev->num_comp_vectors /
3389                                    num_online_nodes() + target->comp_vector)
3390                                   % ibdev->num_comp_vectors;
3391                int cpu_idx = 0;
3392
3393                for_each_online_cpu(cpu) {
3394                        if (cpu_to_node(cpu) != node)
3395                                continue;
3396                        if (ch_start + cpu_idx >= ch_end)
3397                                continue;
3398                        ch = &target->ch[ch_start + cpu_idx];
3399                        ch->target = target;
3400                        ch->comp_vector = cv_start == cv_end ? cv_start :
3401                                cv_start + cpu_idx % (cv_end - cv_start);
3402                        spin_lock_init(&ch->lock);
3403                        INIT_LIST_HEAD(&ch->free_tx);
3404                        ret = srp_new_cm_id(ch);
3405                        if (ret)
3406                                goto err_disconnect;
3407
3408                        ret = srp_create_ch_ib(ch);
3409                        if (ret)
3410                                goto err_disconnect;
3411
3412                        ret = srp_alloc_req_data(ch);
3413                        if (ret)
3414                                goto err_disconnect;
3415
3416                        ret = srp_connect_ch(ch, multich);
3417                        if (ret) {
3418                                shost_printk(KERN_ERR, target->scsi_host,
3419                                             PFX "Connection %d/%d failed\n",
3420                                             ch_start + cpu_idx,
3421                                             target->ch_count);
3422                                if (node_idx == 0 && cpu_idx == 0) {
3423                                        goto err_disconnect;
3424                                } else {
3425                                        srp_free_ch_ib(target, ch);
3426                                        srp_free_req_data(target, ch);
3427                                        target->ch_count = ch - target->ch;
3428                                        goto connected;
3429                                }
3430                        }
3431
3432                        multich = true;
3433                        cpu_idx++;
3434                }
3435                node_idx++;
3436        }
3437
3438connected:
3439        target->scsi_host->nr_hw_queues = target->ch_count;
3440
3441        ret = srp_add_target(host, target);
3442        if (ret)
3443                goto err_disconnect;
3444
3445        if (target->state != SRP_TARGET_REMOVED) {
3446                shost_printk(KERN_DEBUG, target->scsi_host, PFX
3447                             "new target: id_ext %016llx ioc_guid %016llx pkey %04x service_id %016llx sgid %pI6 dgid %pI6\n",
3448                             be64_to_cpu(target->id_ext),
3449                             be64_to_cpu(target->ioc_guid),
3450                             be16_to_cpu(target->pkey),
3451                             be64_to_cpu(target->service_id),
3452                             target->sgid.raw, target->orig_dgid.raw);
3453        }
3454
3455        ret = count;
3456
3457out:
3458        mutex_unlock(&host->add_target_mutex);
3459
3460        scsi_host_put(target->scsi_host);
3461        if (ret < 0)
3462                scsi_host_put(target->scsi_host);
3463
3464        return ret;
3465
3466err_disconnect:
3467        srp_disconnect_target(target);
3468
3469        for (i = 0; i < target->ch_count; i++) {
3470                ch = &target->ch[i];
3471                srp_free_ch_ib(target, ch);
3472                srp_free_req_data(target, ch);
3473        }
3474
3475        kfree(target->ch);
3476        goto out;
3477}
3478
3479static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
3480
3481static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
3482                          char *buf)
3483{
3484        struct srp_host *host = container_of(dev, struct srp_host, dev);
3485
3486        return sprintf(buf, "%s\n", host->srp_dev->dev->name);
3487}
3488
3489static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
3490
3491static ssize_t show_port(struct device *dev, struct device_attribute *attr,
3492                         char *buf)
3493{
3494        struct srp_host *host = container_of(dev, struct srp_host, dev);
3495
3496        return sprintf(buf, "%d\n", host->port);
3497}
3498
3499static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
3500
3501static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
3502{
3503        struct srp_host *host;
3504
3505        host = kzalloc(sizeof *host, GFP_KERNEL);
3506        if (!host)
3507                return NULL;
3508
3509        INIT_LIST_HEAD(&host->target_list);
3510        spin_lock_init(&host->target_lock);
3511        init_completion(&host->released);
3512        mutex_init(&host->add_target_mutex);
3513        host->srp_dev = device;
3514        host->port = port;
3515
3516        host->dev.class = &srp_class;
3517        host->dev.parent = device->dev->dma_device;
3518        dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port);
3519
3520        if (device_register(&host->dev))
3521                goto free_host;
3522        if (device_create_file(&host->dev, &dev_attr_add_target))
3523                goto err_class;
3524        if (device_create_file(&host->dev, &dev_attr_ibdev))
3525                goto err_class;
3526        if (device_create_file(&host->dev, &dev_attr_port))
3527                goto err_class;
3528
3529        return host;
3530
3531err_class:
3532        device_unregister(&host->dev);
3533
3534free_host:
3535        kfree(host);
3536
3537        return NULL;
3538}
3539
3540static void srp_add_one(struct ib_device *device)
3541{
3542        struct srp_device *srp_dev;
3543        struct srp_host *host;
3544        int mr_page_shift, p;
3545        u64 max_pages_per_mr;
3546        unsigned int flags = 0;
3547
3548        srp_dev = kzalloc(sizeof(*srp_dev), GFP_KERNEL);
3549        if (!srp_dev)
3550                return;
3551
3552        /*
3553         * Use the smallest page size supported by the HCA, down to a
3554         * minimum of 4096 bytes. We're unlikely to build large sglists
3555         * out of smaller entries.
3556         */
3557        mr_page_shift           = max(12, ffs(device->attrs.page_size_cap) - 1);
3558        srp_dev->mr_page_size   = 1 << mr_page_shift;
3559        srp_dev->mr_page_mask   = ~((u64) srp_dev->mr_page_size - 1);
3560        max_pages_per_mr        = device->attrs.max_mr_size;
3561        do_div(max_pages_per_mr, srp_dev->mr_page_size);
3562        pr_debug("%s: %llu / %u = %llu <> %u\n", __func__,
3563                 device->attrs.max_mr_size, srp_dev->mr_page_size,
3564                 max_pages_per_mr, SRP_MAX_PAGES_PER_MR);
3565        srp_dev->max_pages_per_mr = min_t(u64, SRP_MAX_PAGES_PER_MR,
3566                                          max_pages_per_mr);
3567
3568        srp_dev->has_fmr = (device->alloc_fmr && device->dealloc_fmr &&
3569                            device->map_phys_fmr && device->unmap_fmr);
3570        srp_dev->has_fr = (device->attrs.device_cap_flags &
3571                           IB_DEVICE_MEM_MGT_EXTENSIONS);
3572        if (!never_register && !srp_dev->has_fmr && !srp_dev->has_fr) {
3573                dev_warn(&device->dev, "neither FMR nor FR is supported\n");
3574        } else if (!never_register &&
3575                   device->attrs.max_mr_size >= 2 * srp_dev->mr_page_size) {
3576                srp_dev->use_fast_reg = (srp_dev->has_fr &&
3577                                         (!srp_dev->has_fmr || prefer_fr));
3578                srp_dev->use_fmr = !srp_dev->use_fast_reg && srp_dev->has_fmr;
3579        }
3580
3581        if (never_register || !register_always ||
3582            (!srp_dev->has_fmr && !srp_dev->has_fr))
3583                flags |= IB_PD_UNSAFE_GLOBAL_RKEY;
3584
3585        if (srp_dev->use_fast_reg) {
3586                srp_dev->max_pages_per_mr =
3587                        min_t(u32, srp_dev->max_pages_per_mr,
3588                              device->attrs.max_fast_reg_page_list_len);
3589        }
3590        srp_dev->mr_max_size    = srp_dev->mr_page_size *
3591                                   srp_dev->max_pages_per_mr;
3592        pr_debug("%s: mr_page_shift = %d, device->max_mr_size = %#llx, device->max_fast_reg_page_list_len = %u, max_pages_per_mr = %d, mr_max_size = %#x\n",
3593                 device->name, mr_page_shift, device->attrs.max_mr_size,
3594                 device->attrs.max_fast_reg_page_list_len,
3595                 srp_dev->max_pages_per_mr, srp_dev->mr_max_size);
3596
3597        INIT_LIST_HEAD(&srp_dev->dev_list);
3598
3599        srp_dev->dev = device;
3600        srp_dev->pd  = ib_alloc_pd(device, flags);
3601        if (IS_ERR(srp_dev->pd))
3602                goto free_dev;
3603
3604
3605        for (p = rdma_start_port(device); p <= rdma_end_port(device); ++p) {
3606                host = srp_add_port(srp_dev, p);
3607                if (host)
3608                        list_add_tail(&host->list, &srp_dev->dev_list);
3609        }
3610
3611        ib_set_client_data(device, &srp_client, srp_dev);
3612        return;
3613
3614free_dev:
3615        kfree(srp_dev);
3616}
3617
3618static void srp_remove_one(struct ib_device *device, void *client_data)
3619{
3620        struct srp_device *srp_dev;
3621        struct srp_host *host, *tmp_host;
3622        struct srp_target_port *target;
3623
3624        srp_dev = client_data;
3625        if (!srp_dev)
3626                return;
3627
3628        list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
3629                device_unregister(&host->dev);
3630                /*
3631                 * Wait for the sysfs entry to go away, so that no new
3632                 * target ports can be created.
3633                 */
3634                wait_for_completion(&host->released);
3635
3636                /*
3637                 * Remove all target ports.
3638                 */
3639                spin_lock(&host->target_lock);
3640                list_for_each_entry(target, &host->target_list, list)
3641                        srp_queue_remove_work(target);
3642                spin_unlock(&host->target_lock);
3643
3644                /*
3645                 * Wait for tl_err and target port removal tasks.
3646                 */
3647                flush_workqueue(system_long_wq);
3648                flush_workqueue(srp_remove_wq);
3649
3650                kfree(host);
3651        }
3652
3653        ib_dealloc_pd(srp_dev->pd);
3654
3655        kfree(srp_dev);
3656}
3657
3658static struct srp_function_template ib_srp_transport_functions = {
3659        .has_rport_state         = true,
3660        .reset_timer_if_blocked  = true,
3661        .reconnect_delay         = &srp_reconnect_delay,
3662        .fast_io_fail_tmo        = &srp_fast_io_fail_tmo,
3663        .dev_loss_tmo            = &srp_dev_loss_tmo,
3664        .reconnect               = srp_rport_reconnect,
3665        .rport_delete            = srp_rport_delete,
3666        .terminate_rport_io      = srp_terminate_io,
3667};
3668
3669static int __init srp_init_module(void)
3670{
3671        int ret;
3672
3673        if (srp_sg_tablesize) {
3674                pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
3675                if (!cmd_sg_entries)
3676                        cmd_sg_entries = srp_sg_tablesize;
3677        }
3678
3679        if (!cmd_sg_entries)
3680                cmd_sg_entries = SRP_DEF_SG_TABLESIZE;
3681
3682        if (cmd_sg_entries > 255) {
3683                pr_warn("Clamping cmd_sg_entries to 255\n");
3684                cmd_sg_entries = 255;
3685        }
3686
3687        if (!indirect_sg_entries)
3688                indirect_sg_entries = cmd_sg_entries;
3689        else if (indirect_sg_entries < cmd_sg_entries) {
3690                pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n",
3691                        cmd_sg_entries);
3692                indirect_sg_entries = cmd_sg_entries;
3693        }
3694
3695        if (indirect_sg_entries > SG_MAX_SEGMENTS) {
3696                pr_warn("Clamping indirect_sg_entries to %u\n",
3697                        SG_MAX_SEGMENTS);
3698                indirect_sg_entries = SG_MAX_SEGMENTS;
3699        }
3700
3701        srp_remove_wq = create_workqueue("srp_remove");
3702        if (!srp_remove_wq) {
3703                ret = -ENOMEM;
3704                goto out;
3705        }
3706
3707        ret = -ENOMEM;
3708        ib_srp_transport_template =
3709                srp_attach_transport(&ib_srp_transport_functions);
3710        if (!ib_srp_transport_template)
3711                goto destroy_wq;
3712
3713        ret = class_register(&srp_class);
3714        if (ret) {
3715                pr_err("couldn't register class infiniband_srp\n");
3716                goto release_tr;
3717        }
3718
3719        ib_sa_register_client(&srp_sa_client);
3720
3721        ret = ib_register_client(&srp_client);
3722        if (ret) {
3723                pr_err("couldn't register IB client\n");
3724                goto unreg_sa;
3725        }
3726
3727out:
3728        return ret;
3729
3730unreg_sa:
3731        ib_sa_unregister_client(&srp_sa_client);
3732        class_unregister(&srp_class);
3733
3734release_tr:
3735        srp_release_transport(ib_srp_transport_template);
3736
3737destroy_wq:
3738        destroy_workqueue(srp_remove_wq);
3739        goto out;
3740}
3741
3742static void __exit srp_cleanup_module(void)
3743{
3744        ib_unregister_client(&srp_client);
3745        ib_sa_unregister_client(&srp_sa_client);
3746        class_unregister(&srp_class);
3747        srp_release_transport(ib_srp_transport_template);
3748        destroy_workqueue(srp_remove_wq);
3749}
3750
3751module_init(srp_init_module);
3752module_exit(srp_cleanup_module);
Note: See TracBrowser for help on using the repository browser.