sys/dev/cxgbe/cxgbei/icl_cxgbei.c

   1 /*-
   2  * Copyright (c) 2012 The FreeBSD Foundation
   3  * Copyright (c) 2015 Chelsio Communications, Inc.
   4  * All rights reserved.
   5  *
   6  * This software was developed by Edward Tomasz Napierala under sponsorship
   7  * from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  */
  31
  32 /*
  33  * cxgbei implementation of iSCSI Common Layer kobj(9) interface.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include "opt_inet.h"
  40 #include "opt_inet6.h"
  41
  42 #ifdef TCP_OFFLOAD
  43 #include <sys/param.h>
  44 #include <sys/capsicum.h>
  45 #include <sys/condvar.h>
  46 #include <sys/conf.h>
  47 #include <sys/file.h>
  48 #include <sys/kernel.h>
  49 #include <sys/kthread.h>
  50 #include <sys/lock.h>
  51 #include <sys/mbuf.h>
  52 #include <sys/mutex.h>
  53 #include <sys/module.h>
  54 #include <sys/protosw.h>
  55 #include <sys/socket.h>
  56 #include <sys/socketvar.h>
  57 #include <sys/sysctl.h>
  58 #include <sys/systm.h>
  59 #include <sys/sx.h>
  60 #include <sys/uio.h>
  61 #include <machine/bus.h>
  62 #include <vm/uma.h>
  63 #include <vm/vm.h>
  64 #include <vm/pmap.h>
  65 #include <netinet/in.h>
  66 #include <netinet/in_pcb.h>
  67 #include <netinet/tcp.h>
  68 #include <netinet/tcp_var.h>
  69 #include <netinet/toecore.h>
  70
  71 #include <dev/iscsi/icl.h>
  72 #include <dev/iscsi/iscsi_proto.h>
  73 #include <icl_conn_if.h>
  74
  75 #include <cam/scsi/scsi_all.h>
  76 #include <cam/scsi/scsi_da.h>
  77 #include <cam/ctl/ctl_io.h>
  78 #include <cam/ctl/ctl.h>
  79 #include <cam/ctl/ctl_backend.h>
  80 #include <cam/ctl/ctl_error.h>
  81 #include <cam/ctl/ctl_frontend.h>
  82 #include <cam/ctl/ctl_debug.h>
  83 #include <cam/ctl/ctl_ha.h>
  84 #include <cam/ctl/ctl_ioctl.h>
  85
  86 #include <cam/cam.h>
  87 #include <cam/cam_ccb.h>
  88 #include <cam/cam_xpt.h>
  89 #include <cam/cam_debug.h>
  90 #include <cam/cam_sim.h>
  91 #include <cam/cam_xpt_sim.h>
  92 #include <cam/cam_xpt_periph.h>
  93 #include <cam/cam_periph.h>
  94 #include <cam/cam_compat.h>
  95 #include <cam/scsi/scsi_message.h>
  96
  97 #include "common/common.h"
  98 #include "common/t4_tcb.h"
  99 #include "tom/t4_tom.h"
 100 #include "cxgbei.h"
 101
 102 SYSCTL_NODE(_kern_icl, OID_AUTO, cxgbei, CTLFLAG_RD, 0, "Chelsio iSCSI offload");
 103 static int coalesce = 1;
 104 SYSCTL_INT(_kern_icl_cxgbei, OID_AUTO, coalesce, CTLFLAG_RWTUN,
 105         &coalesce, 0, "Try to coalesce PDUs before sending");
 106 static int partial_receive_len = 128 * 1024;
 107 SYSCTL_INT(_kern_icl_cxgbei, OID_AUTO, partial_receive_len, CTLFLAG_RWTUN,
 108     &partial_receive_len, 0, "Minimum read size for partially received "
 109     "data segment");
 110 static int sendspace = 1048576;
 111 SYSCTL_INT(_kern_icl_cxgbei, OID_AUTO, sendspace, CTLFLAG_RWTUN,
 112     &sendspace, 0, "Default send socket buffer size");
 113 static int recvspace = 1048576;
 114 SYSCTL_INT(_kern_icl_cxgbei, OID_AUTO, recvspace, CTLFLAG_RWTUN,
 115     &recvspace, 0, "Default receive socket buffer size");
 116
 117 static uma_zone_t prsv_zone;
 118 static volatile u_int icl_cxgbei_ncons;
 119
 120 #define ICL_CONN_LOCK(X)                mtx_lock(X->ic_lock)
 121 #define ICL_CONN_UNLOCK(X)              mtx_unlock(X->ic_lock)
 122 #define ICL_CONN_LOCK_ASSERT(X)         mtx_assert(X->ic_lock, MA_OWNED)
 123 #define ICL_CONN_LOCK_ASSERT_NOT(X)     mtx_assert(X->ic_lock, MA_NOTOWNED)
 124
 125 struct icl_pdu *icl_cxgbei_new_pdu(int);
 126 void icl_cxgbei_new_pdu_set_conn(struct icl_pdu *, struct icl_conn *);
 127
 128 static icl_conn_new_pdu_t       icl_cxgbei_conn_new_pdu;
 129 icl_conn_pdu_free_t     icl_cxgbei_conn_pdu_free;
 130 static icl_conn_pdu_data_segment_length_t
 131                                     icl_cxgbei_conn_pdu_data_segment_length;
 132 static icl_conn_pdu_append_data_t       icl_cxgbei_conn_pdu_append_data;
 133 static icl_conn_pdu_get_data_t  icl_cxgbei_conn_pdu_get_data;
 134 static icl_conn_pdu_queue_t     icl_cxgbei_conn_pdu_queue;
 135 static icl_conn_handoff_t       icl_cxgbei_conn_handoff;
 136 static icl_conn_free_t          icl_cxgbei_conn_free;
 137 static icl_conn_close_t         icl_cxgbei_conn_close;
 138 static icl_conn_task_setup_t    icl_cxgbei_conn_task_setup;
 139 static icl_conn_task_done_t     icl_cxgbei_conn_task_done;
 140 static icl_conn_transfer_setup_t        icl_cxgbei_conn_transfer_setup;
 141 static icl_conn_transfer_done_t icl_cxgbei_conn_transfer_done;
 142
 143 static kobj_method_t icl_cxgbei_methods[] = {
 144         KOBJMETHOD(icl_conn_new_pdu, icl_cxgbei_conn_new_pdu),
 145         KOBJMETHOD(icl_conn_pdu_free, icl_cxgbei_conn_pdu_free),
 146         KOBJMETHOD(icl_conn_pdu_data_segment_length,
 147             icl_cxgbei_conn_pdu_data_segment_length),
 148         KOBJMETHOD(icl_conn_pdu_append_data, icl_cxgbei_conn_pdu_append_data),
 149         KOBJMETHOD(icl_conn_pdu_get_data, icl_cxgbei_conn_pdu_get_data),
 150         KOBJMETHOD(icl_conn_pdu_queue, icl_cxgbei_conn_pdu_queue),
 151         KOBJMETHOD(icl_conn_handoff, icl_cxgbei_conn_handoff),
 152         KOBJMETHOD(icl_conn_free, icl_cxgbei_conn_free),
 153         KOBJMETHOD(icl_conn_close, icl_cxgbei_conn_close),
 154         KOBJMETHOD(icl_conn_task_setup, icl_cxgbei_conn_task_setup),
 155         KOBJMETHOD(icl_conn_task_done, icl_cxgbei_conn_task_done),
 156         KOBJMETHOD(icl_conn_transfer_setup, icl_cxgbei_conn_transfer_setup),
 157         KOBJMETHOD(icl_conn_transfer_done, icl_cxgbei_conn_transfer_done),
 158         { 0, 0 }
 159 };
 160
 161 DEFINE_CLASS(icl_cxgbei, icl_cxgbei_methods, sizeof(struct icl_cxgbei_conn));
 162
 163 void
 164 icl_cxgbei_conn_pdu_free(struct icl_conn *ic, struct icl_pdu *ip)
 165 {
 166 #ifdef INVARIANTS
 167         struct icl_cxgbei_pdu *icp = ip_to_icp(ip);
 168 #endif
 169
 170         MPASS(icp->icp_signature == CXGBEI_PDU_SIGNATURE);
 171         MPASS(ic == ip->ip_conn);
 172         MPASS(ip->ip_bhs_mbuf != NULL);
 173
 174         m_freem(ip->ip_ahs_mbuf);
 175         m_freem(ip->ip_data_mbuf);
 176         m_freem(ip->ip_bhs_mbuf);       /* storage for icl_cxgbei_pdu itself */
 177
 178 #ifdef DIAGNOSTIC
 179         if (__predict_true(ic != NULL))
 180                 refcount_release(&ic->ic_outstanding_pdus);
 181 #endif
 182 }
 183
 184 struct icl_pdu *
 185 icl_cxgbei_new_pdu(int flags)
 186 {
 187         struct icl_cxgbei_pdu *icp;
 188         struct icl_pdu *ip;
 189         struct mbuf *m;
 190         uintptr_t a;
 191
 192         m = m_gethdr(flags, MT_DATA);
 193         if (__predict_false(m == NULL))
 194                 return (NULL);
 195
 196         a = roundup2(mtod(m, uintptr_t), _Alignof(struct icl_cxgbei_pdu));
 197         icp = (struct icl_cxgbei_pdu *)a;
 198         bzero(icp, sizeof(*icp));
 199
 200         icp->icp_signature = CXGBEI_PDU_SIGNATURE;
 201         ip = &icp->ip;
 202         ip->ip_bhs_mbuf = m;
 203
 204         a = roundup2((uintptr_t)(icp + 1), _Alignof(struct iscsi_bhs *));
 205         ip->ip_bhs = (struct iscsi_bhs *)a;
 206 #ifdef INVARIANTS
 207         /* Everything must fit entirely in the mbuf. */
 208         a = (uintptr_t)(ip->ip_bhs + 1);
 209         MPASS(a <= (uintptr_t)m + MSIZE);
 210 #endif
 211         bzero(ip->ip_bhs, sizeof(*ip->ip_bhs));
 212
 213         m->m_data = (void *)ip->ip_bhs;
 214         m->m_len = sizeof(struct iscsi_bhs);
 215         m->m_pkthdr.len = m->m_len;
 216
 217         return (ip);
 218 }
 219
 220 void
 221 icl_cxgbei_new_pdu_set_conn(struct icl_pdu *ip, struct icl_conn *ic)
 222 {
 223
 224         ip->ip_conn = ic;
 225 #ifdef DIAGNOSTIC
 226         refcount_acquire(&ic->ic_outstanding_pdus);
 227 #endif
 228 }
 229
 230 /*
 231  * Allocate icl_pdu with empty BHS to fill up by the caller.
 232  */
 233 static struct icl_pdu *
 234 icl_cxgbei_conn_new_pdu(struct icl_conn *ic, int flags)
 235 {
 236         struct icl_pdu *ip;
 237
 238         ip = icl_cxgbei_new_pdu(flags);
 239         if (__predict_false(ip == NULL))
 240                 return (NULL);
 241         icl_cxgbei_new_pdu_set_conn(ip, ic);
 242
 243         return (ip);
 244 }
 245
 246 static size_t
 247 icl_pdu_data_segment_length(const struct icl_pdu *request)
 248 {
 249         uint32_t len = 0;
 250
 251         len += request->ip_bhs->bhs_data_segment_len[0];
 252         len <<= 8;
 253         len += request->ip_bhs->bhs_data_segment_len[1];
 254         len <<= 8;
 255         len += request->ip_bhs->bhs_data_segment_len[2];
 256
 257         return (len);
 258 }
 259
 260 size_t
 261 icl_cxgbei_conn_pdu_data_segment_length(struct icl_conn *ic,
 262     const struct icl_pdu *request)
 263 {
 264
 265         return (icl_pdu_data_segment_length(request));
 266 }
 267
 268 static struct mbuf *
 269 finalize_pdu(struct icl_cxgbei_conn *icc, struct icl_cxgbei_pdu *icp)
 270 {
 271         struct icl_pdu *ip = &icp->ip;
 272         uint8_t ulp_submode, padding;
 273         struct mbuf *m, *last;
 274         struct iscsi_bhs *bhs;
 275
 276         /*
 277          * Fix up the data segment mbuf first.
 278          */
 279         m = ip->ip_data_mbuf;
 280         ulp_submode = icc->ulp_submode;
 281         if (m) {
 282                 last = m_last(m);
 283
 284                 /*
 285                  * Round up the data segment to a 4B boundary.  Pad with 0 if
 286                  * necessary.  There will definitely be room in the mbuf.
 287                  */
 288                 padding = roundup2(ip->ip_data_len, 4) - ip->ip_data_len;
 289                 if (padding) {
 290                         bzero(mtod(last, uint8_t *) + last->m_len, padding);
 291                         last->m_len += padding;
 292                 }
 293         } else {
 294                 MPASS(ip->ip_data_len == 0);
 295                 ulp_submode &= ~ULP_CRC_DATA;
 296                 padding = 0;
 297         }
 298
 299         /*
 300          * Now the header mbuf that has the BHS.
 301          */
 302         m = ip->ip_bhs_mbuf;
 303         MPASS(m->m_pkthdr.len == sizeof(struct iscsi_bhs));
 304         MPASS(m->m_len == sizeof(struct iscsi_bhs));
 305
 306         bhs = ip->ip_bhs;
 307         bhs->bhs_data_segment_len[2] = ip->ip_data_len;
 308         bhs->bhs_data_segment_len[1] = ip->ip_data_len >> 8;
 309         bhs->bhs_data_segment_len[0] = ip->ip_data_len >> 16;
 310
 311         /* "Convert" PDU to mbuf chain.  Do not use icp/ip after this. */
 312         m->m_pkthdr.len = sizeof(struct iscsi_bhs) + ip->ip_data_len + padding;
 313         m->m_next = ip->ip_data_mbuf;
 314         set_mbuf_ulp_submode(m, ulp_submode);
 315 #ifdef INVARIANTS
 316         bzero(icp, sizeof(*icp));
 317 #endif
 318 #ifdef DIAGNOSTIC
 319         refcount_release(&icc->ic.ic_outstanding_pdus);
 320 #endif
 321
 322         return (m);
 323 }
 324
 325 int
 326 icl_cxgbei_conn_pdu_append_data(struct icl_conn *ic, struct icl_pdu *ip,
 327     const void *addr, size_t len, int flags)
 328 {
 329         struct mbuf *m;
 330 #ifdef INVARIANTS
 331         struct icl_cxgbei_pdu *icp = ip_to_icp(ip);
 332 #endif
 333
 334         MPASS(icp->icp_signature == CXGBEI_PDU_SIGNATURE);
 335         MPASS(ic == ip->ip_conn);
 336         KASSERT(len > 0, ("%s: len is %jd", __func__, (intmax_t)len));
 337
 338         m = ip->ip_data_mbuf;
 339         if (m == NULL) {
 340                 m = m_getjcl(M_NOWAIT, MT_DATA, 0, MJUM16BYTES);
 341                 if (__predict_false(m == NULL))
 342                         return (ENOMEM);
 343
 344                 ip->ip_data_mbuf = m;
 345         }
 346
 347         if (__predict_true(m_append(m, len, addr) != 0)) {
 348                 ip->ip_data_len += len;
 349                 MPASS(ip->ip_data_len <= ic->ic_max_data_segment_length);
 350                 return (0);
 351         } else {
 352                 if (flags & M_WAITOK) {
 353                         CXGBE_UNIMPLEMENTED("fail safe append");
 354                 }
 355                 ip->ip_data_len = m_length(m, NULL);
 356                 return (1);
 357         }
 358 }
 359
 360 void
 361 icl_cxgbei_conn_pdu_get_data(struct icl_conn *ic, struct icl_pdu *ip,
 362     size_t off, void *addr, size_t len)
 363 {
 364         struct icl_cxgbei_pdu *icp = ip_to_icp(ip);
 365
 366         if (icp->icp_flags & ICPF_RX_DDP)
 367                 return; /* data is DDP'ed, no need to copy */
 368         m_copydata(ip->ip_data_mbuf, off, len, addr);
 369 }
 370
 371 void
 372 icl_cxgbei_conn_pdu_queue(struct icl_conn *ic, struct icl_pdu *ip)
 373 {
 374         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 375         struct icl_cxgbei_pdu *icp = ip_to_icp(ip);
 376         struct socket *so = ic->ic_socket;
 377         struct toepcb *toep = icc->toep;
 378         struct inpcb *inp;
 379         struct mbuf *m;
 380
 381         MPASS(ic == ip->ip_conn);
 382         MPASS(ip->ip_bhs_mbuf != NULL);
 383         /* The kernel doesn't generate PDUs with AHS. */
 384         MPASS(ip->ip_ahs_mbuf == NULL && ip->ip_ahs_len == 0);
 385
 386         ICL_CONN_LOCK_ASSERT(ic);
 387         /* NOTE: sowriteable without so_snd lock is a mostly harmless race. */
 388         if (ic->ic_disconnecting || so == NULL || !sowriteable(so)) {
 389                 icl_cxgbei_conn_pdu_free(ic, ip);
 390                 return;
 391         }
 392
 393         m = finalize_pdu(icc, icp);
 394         M_ASSERTPKTHDR(m);
 395         MPASS((m->m_pkthdr.len & 3) == 0);
 396
 397         /*
 398          * Do not get inp from toep->inp as the toepcb might have detached
 399          * already.
 400          */
 401         inp = sotoinpcb(so);
 402         INP_WLOCK(inp);
 403         if (__predict_false(inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT)) ||
 404             __predict_false((toep->flags & TPF_ATTACHED) == 0))
 405                 m_freem(m);
 406         else {
 407                 mbufq_enqueue(&toep->ulp_pduq, m);
 408                 t4_push_pdus(icc->sc, toep, 0);
 409         }
 410         INP_WUNLOCK(inp);
 411 }
 412
 413 static struct icl_conn *
 414 icl_cxgbei_new_conn(const char *name, struct mtx *lock)
 415 {
 416         struct icl_cxgbei_conn *icc;
 417         struct icl_conn *ic;
 418
 419         refcount_acquire(&icl_cxgbei_ncons);
 420
 421         icc = (struct icl_cxgbei_conn *)kobj_create(&icl_cxgbei_class, M_CXGBE,
 422             M_WAITOK | M_ZERO);
 423         icc->icc_signature = CXGBEI_CONN_SIGNATURE;
 424         STAILQ_INIT(&icc->rcvd_pdus);
 425
 426         ic = &icc->ic;
 427         ic->ic_lock = lock;
 428
 429         /* XXXNP: review.  Most of these icl_conn fields aren't really used */
 430         STAILQ_INIT(&ic->ic_to_send);
 431         cv_init(&ic->ic_send_cv, "icl_cxgbei_tx");
 432         cv_init(&ic->ic_receive_cv, "icl_cxgbei_rx");
 433 #ifdef DIAGNOSTIC
 434         refcount_init(&ic->ic_outstanding_pdus, 0);
 435 #endif
 436         /* This is a stop-gap value that will be corrected during handoff. */
 437         ic->ic_max_data_segment_length = 16384;
 438         ic->ic_name = name;
 439         ic->ic_offload = "cxgbei";
 440         ic->ic_unmapped = false;
 441
 442         CTR2(KTR_CXGBE, "%s: icc %p", __func__, icc);
 443
 444         return (ic);
 445 }
 446
 447 void
 448 icl_cxgbei_conn_free(struct icl_conn *ic)
 449 {
 450         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 451
 452         MPASS(icc->icc_signature == CXGBEI_CONN_SIGNATURE);
 453
 454         CTR2(KTR_CXGBE, "%s: icc %p", __func__, icc);
 455
 456         cv_destroy(&ic->ic_send_cv);
 457         cv_destroy(&ic->ic_receive_cv);
 458
 459         kobj_delete((struct kobj *)icc, M_CXGBE);
 460         refcount_release(&icl_cxgbei_ncons);
 461 }
 462
 463 static int
 464 icl_cxgbei_setsockopt(struct icl_conn *ic, struct socket *so, int sspace,
 465     int rspace)
 466 {
 467         struct sockopt opt;
 468         int error, one = 1, ss, rs;
 469
 470         ss = max(sendspace, sspace);
 471         rs = max(recvspace, rspace);
 472
 473         error = soreserve(so, ss, rs);
 474         if (error != 0) {
 475                 icl_cxgbei_conn_close(ic);
 476                 return (error);
 477         }
 478         SOCKBUF_LOCK(&so->so_snd);
 479         so->so_snd.sb_flags |= SB_AUTOSIZE;
 480         SOCKBUF_UNLOCK(&so->so_snd);
 481         SOCKBUF_LOCK(&so->so_rcv);
 482         so->so_rcv.sb_flags |= SB_AUTOSIZE;
 483         SOCKBUF_UNLOCK(&so->so_rcv);
 484
 485         /*
 486          * Disable Nagle.
 487          */
 488         bzero(&opt, sizeof(opt));
 489         opt.sopt_dir = SOPT_SET;
 490         opt.sopt_level = IPPROTO_TCP;
 491         opt.sopt_name = TCP_NODELAY;
 492         opt.sopt_val = &one;
 493         opt.sopt_valsize = sizeof(one);
 494         error = sosetopt(so, &opt);
 495         if (error != 0) {
 496                 icl_cxgbei_conn_close(ic);
 497                 return (error);
 498         }
 499
 500         return (0);
 501 }
 502
 503 /*
 504  * Request/response structure used to find out the adapter offloading a socket.
 505  */
 506 struct find_ofld_adapter_rr {
 507         struct socket *so;
 508         struct adapter *sc;     /* result */
 509 };
 510
 511 static void
 512 find_offload_adapter(struct adapter *sc, void *arg)
 513 {
 514         struct find_ofld_adapter_rr *fa = arg;
 515         struct socket *so = fa->so;
 516         struct tom_data *td = sc->tom_softc;
 517         struct tcpcb *tp;
 518         struct inpcb *inp;
 519
 520         /* Non-TCP were filtered out earlier. */
 521         MPASS(so->so_proto->pr_protocol == IPPROTO_TCP);
 522
 523         if (fa->sc != NULL)
 524                 return; /* Found already. */
 525
 526         if (td == NULL)
 527                 return; /* TOE not enabled on this adapter. */
 528
 529         inp = sotoinpcb(so);
 530         INP_WLOCK(inp);
 531         if ((inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT)) == 0) {
 532                 tp = intotcpcb(inp);
 533                 if (tp->t_flags & TF_TOE && tp->tod == &td->tod)
 534                         fa->sc = sc;    /* Found. */
 535         }
 536         INP_WUNLOCK(inp);
 537 }
 538
 539 /* XXXNP: move this to t4_tom. */
 540 static void
 541 send_iscsi_flowc_wr(struct adapter *sc, struct toepcb *toep, int maxlen)
 542 {
 543         struct wrqe *wr;
 544         struct fw_flowc_wr *flowc;
 545         const u_int nparams = 1;
 546         u_int flowclen;
 547         struct ofld_tx_sdesc *txsd = &toep->txsd[toep->txsd_pidx];
 548
 549         flowclen = sizeof(*flowc) + nparams * sizeof(struct fw_flowc_mnemval);
 550
 551         wr = alloc_wrqe(roundup2(flowclen, 16), toep->ofld_txq);
 552         if (wr == NULL) {
 553                 /* XXX */
 554                 panic("%s: allocation failure.", __func__);
 555         }
 556         flowc = wrtod(wr);
 557         memset(flowc, 0, wr->wr_len);
 558
 559         flowc->op_to_nparams = htobe32(V_FW_WR_OP(FW_FLOWC_WR) |
 560             V_FW_FLOWC_WR_NPARAMS(nparams));
 561         flowc->flowid_len16 = htonl(V_FW_WR_LEN16(howmany(flowclen, 16)) |
 562             V_FW_WR_FLOWID(toep->tid));
 563
 564         flowc->mnemval[0].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;
 565         flowc->mnemval[0].val = htobe32(maxlen);
 566
 567         txsd->tx_credits = howmany(flowclen, 16);
 568         txsd->plen = 0;
 569         KASSERT(toep->tx_credits >= txsd->tx_credits && toep->txsd_avail > 0,
 570             ("%s: not enough credits (%d)", __func__, toep->tx_credits));
 571         toep->tx_credits -= txsd->tx_credits;
 572         if (__predict_false(++toep->txsd_pidx == toep->txsd_total))
 573                 toep->txsd_pidx = 0;
 574         toep->txsd_avail--;
 575
 576         t4_wrq_tx(sc, wr);
 577 }
 578
 579 static void
 580 set_ulp_mode_iscsi(struct adapter *sc, struct toepcb *toep, int hcrc, int dcrc)
 581 {
 582         uint64_t val = ULP_MODE_ISCSI;
 583
 584         if (hcrc)
 585                 val |= ULP_CRC_HEADER << 4;
 586         if (dcrc)
 587                 val |= ULP_CRC_DATA << 4;
 588
 589         CTR4(KTR_CXGBE, "%s: tid %u, ULP_MODE_ISCSI, CRC hdr=%d data=%d",
 590             __func__, toep->tid, hcrc, dcrc);
 591
 592         t4_set_tcb_field(sc, toep->ctrlq, toep, W_TCB_ULP_TYPE,
 593             V_TCB_ULP_TYPE(M_TCB_ULP_TYPE) | V_TCB_ULP_RAW(M_TCB_ULP_RAW), val,
 594             0, 0);
 595 }
 596
 597 /*
 598  * XXXNP: Who is responsible for cleaning up the socket if this returns with an
 599  * error?  Review all error paths.
 600  *
 601  * XXXNP: What happens to the socket's fd reference if the operation is
 602  * successful, and how does that affect the socket's life cycle?
 603  */
 604 int
 605 icl_cxgbei_conn_handoff(struct icl_conn *ic, int fd)
 606 {
 607         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 608         struct cxgbei_data *ci;
 609         struct find_ofld_adapter_rr fa;
 610         struct file *fp;
 611         struct socket *so;
 612         struct inpcb *inp;
 613         struct tcpcb *tp;
 614         struct toepcb *toep;
 615         cap_rights_t rights;
 616         int error;
 617
 618         MPASS(icc->icc_signature == CXGBEI_CONN_SIGNATURE);
 619         ICL_CONN_LOCK_ASSERT_NOT(ic);
 620
 621         /*
 622          * Steal the socket from userland.
 623          */
 624         error = fget(curthread, fd,
 625             cap_rights_init(&rights, CAP_SOCK_CLIENT), &fp);
 626         if (error != 0)
 627                 return (error);
 628         if (fp->f_type != DTYPE_SOCKET) {
 629                 fdrop(fp, curthread);
 630                 return (EINVAL);
 631         }
 632         so = fp->f_data;
 633         if (so->so_type != SOCK_STREAM ||
 634             so->so_proto->pr_protocol != IPPROTO_TCP) {
 635                 fdrop(fp, curthread);
 636                 return (EINVAL);
 637         }
 638
 639         ICL_CONN_LOCK(ic);
 640         if (ic->ic_socket != NULL) {
 641                 ICL_CONN_UNLOCK(ic);
 642                 fdrop(fp, curthread);
 643                 return (EBUSY);
 644         }
 645         ic->ic_disconnecting = false;
 646         ic->ic_socket = so;
 647         fp->f_ops = &badfileops;
 648         fp->f_data = NULL;
 649         fdrop(fp, curthread);
 650         ICL_CONN_UNLOCK(ic);
 651
 652         /* Find the adapter offloading this socket. */
 653         fa.sc = NULL;
 654         fa.so = so;
 655         t4_iterate(find_offload_adapter, &fa);
 656         if (fa.sc == NULL)
 657                 return (EINVAL);
 658         icc->sc = fa.sc;
 659         ci = icc->sc->iscsi_ulp_softc;
 660
 661         inp = sotoinpcb(so);
 662         INP_WLOCK(inp);
 663         tp = intotcpcb(inp);
 664         if (inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT))
 665                 error = EBUSY;
 666         else {
 667                 /*
 668                  * socket could not have been "unoffloaded" if here.
 669                  */
 670                 MPASS(tp->t_flags & TF_TOE);
 671                 MPASS(tp->tod != NULL);
 672                 MPASS(tp->t_toe != NULL);
 673                 toep = tp->t_toe;
 674                 MPASS(toep->vi->pi->adapter == icc->sc);
 675                 icc->toep = toep;
 676                 icc->cwt = cxgbei_select_worker_thread(icc);
 677
 678                 /*
 679                  * We maintain the _send_ DSL in this field just to have a
 680                  * convenient way to assert that the kernel never sends
 681                  * oversized PDUs.  This field is otherwise unused in the driver
 682                  * or the kernel.
 683                  */
 684                 ic->ic_max_data_segment_length = ci->max_tx_pdu_len -
 685                     ISCSI_BHS_SIZE;
 686
 687                 icc->ulp_submode = 0;
 688                 if (ic->ic_header_crc32c) {
 689                         icc->ulp_submode |= ULP_CRC_HEADER;
 690                         ic->ic_max_data_segment_length -=
 691                             ISCSI_HEADER_DIGEST_SIZE;
 692                 }
 693                 if (ic->ic_data_crc32c) {
 694                         icc->ulp_submode |= ULP_CRC_DATA;
 695                         ic->ic_max_data_segment_length -=
 696                             ISCSI_DATA_DIGEST_SIZE;
 697                 }
 698                 so->so_options |= SO_NO_DDP;
 699                 toep->ulp_mode = ULP_MODE_ISCSI;
 700                 toep->ulpcb = icc;
 701
 702                 send_iscsi_flowc_wr(icc->sc, toep, ci->max_tx_pdu_len);
 703                 set_ulp_mode_iscsi(icc->sc, toep, ic->ic_header_crc32c,
 704                     ic->ic_data_crc32c);
 705                 error = 0;
 706         }
 707         INP_WUNLOCK(inp);
 708
 709         if (error == 0) {
 710                 error = icl_cxgbei_setsockopt(ic, so, ci->max_tx_pdu_len,
 711                     ci->max_rx_pdu_len);
 712         }
 713
 714         return (error);
 715 }
 716
 717 void
 718 icl_cxgbei_conn_close(struct icl_conn *ic)
 719 {
 720         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 721         struct icl_pdu *ip;
 722         struct socket *so;
 723         struct sockbuf *sb;
 724         struct inpcb *inp;
 725         struct toepcb *toep = icc->toep;
 726
 727         MPASS(icc->icc_signature == CXGBEI_CONN_SIGNATURE);
 728         ICL_CONN_LOCK_ASSERT_NOT(ic);
 729
 730         ICL_CONN_LOCK(ic);
 731         so = ic->ic_socket;
 732         if (ic->ic_disconnecting || so == NULL) {
 733                 CTR4(KTR_CXGBE, "%s: icc %p (disconnecting = %d), so %p",
 734                     __func__, icc, ic->ic_disconnecting, so);
 735                 ICL_CONN_UNLOCK(ic);
 736                 return;
 737         }
 738         ic->ic_disconnecting = true;
 739
 740         /* These are unused in this driver right now. */
 741         MPASS(STAILQ_EMPTY(&ic->ic_to_send));
 742         MPASS(ic->ic_receive_pdu == NULL);
 743
 744 #ifdef DIAGNOSTIC
 745         KASSERT(ic->ic_outstanding_pdus == 0,
 746             ("destroying session with %d outstanding PDUs",
 747              ic->ic_outstanding_pdus));
 748 #endif
 749         ICL_CONN_UNLOCK(ic);
 750
 751         CTR3(KTR_CXGBE, "%s: tid %d, icc %p", __func__, toep ? toep->tid : -1,
 752             icc);
 753         inp = sotoinpcb(so);
 754         sb = &so->so_rcv;
 755         INP_WLOCK(inp);
 756         if (toep != NULL) {     /* NULL if connection was never offloaded. */
 757                 toep->ulpcb = NULL;
 758                 mbufq_drain(&toep->ulp_pduq);
 759                 SOCKBUF_LOCK(sb);
 760                 if (icc->rx_flags & RXF_ACTIVE) {
 761                         volatile u_int *p = &icc->rx_flags;
 762
 763                         SOCKBUF_UNLOCK(sb);
 764                         INP_WUNLOCK(inp);
 765
 766                         while (*p & RXF_ACTIVE)
 767                                 pause("conclo", 1);
 768
 769                         INP_WLOCK(inp);
 770                         SOCKBUF_LOCK(sb);
 771                 }
 772
 773                 while (!STAILQ_EMPTY(&icc->rcvd_pdus)) {
 774                         ip = STAILQ_FIRST(&icc->rcvd_pdus);
 775                         STAILQ_REMOVE_HEAD(&icc->rcvd_pdus, ip_next);
 776                         icl_cxgbei_conn_pdu_free(ic, ip);
 777                 }
 778                 SOCKBUF_UNLOCK(sb);
 779         }
 780         INP_WUNLOCK(inp);
 781
 782         ICL_CONN_LOCK(ic);
 783         ic->ic_socket = NULL;
 784         ICL_CONN_UNLOCK(ic);
 785
 786         /*
 787          * XXXNP: we should send RST instead of FIN when PDUs held in various
 788          * queues were purged instead of delivered reliably but soabort isn't
 789          * really general purpose and wouldn't do the right thing here.
 790          */
 791         soclose(so);
 792 }
 793
 794 int
 795 icl_cxgbei_conn_task_setup(struct icl_conn *ic, struct icl_pdu *ip,
 796     struct ccb_scsiio *csio, uint32_t *ittp, void **arg)
 797 {
 798         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 799         struct toepcb *toep = icc->toep;
 800         struct adapter *sc = icc->sc;
 801         struct cxgbei_data *ci = sc->iscsi_ulp_softc;
 802         struct ppod_region *pr = &ci->pr;
 803         struct ppod_reservation *prsv;
 804         uint32_t itt;
 805         int rc = 0;
 806
 807         /* This is for the offload driver's state.  Must not be set already. */
 808         MPASS(arg != NULL);
 809         MPASS(*arg == NULL);
 810
 811         if ((csio->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_IN ||
 812             csio->dxfer_len < ci->ddp_threshold) {
 813 no_ddp:
 814                 /*
 815                  * No DDP for this I/O.  Allocate an ITT (based on the one
 816                  * passed in) that cannot be a valid hardware DDP tag in the
 817                  * iSCSI region.
 818                  */
 819                 itt = *ittp & M_PPOD_TAG;
 820                 itt = V_PPOD_TAG(itt) | pr->pr_invalid_bit;
 821                 *ittp = htobe32(itt);
 822                 MPASS(*arg == NULL);    /* State is maintained for DDP only. */
 823                 if (rc != 0)
 824                         counter_u64_add(ci->ddp_setup_error, 1);
 825                 return (0);
 826         }
 827
 828         /*
 829          * Reserve resources for DDP, update the itt that should be used in the
 830          * PDU, and save DDP specific state for this I/O in *arg.
 831          */
 832
 833         prsv = uma_zalloc(prsv_zone, M_NOWAIT);
 834         if (prsv == NULL) {
 835                 rc = ENOMEM;
 836                 goto no_ddp;
 837         }
 838
 839         /* XXX add support for all CAM_DATA_ types */
 840         MPASS((csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR);
 841         rc = t4_alloc_page_pods_for_buf(pr, (vm_offset_t)csio->data_ptr,
 842             csio->dxfer_len, prsv);
 843         if (rc != 0) {
 844                 uma_zfree(prsv_zone, prsv);
 845                 goto no_ddp;
 846         }
 847
 848         rc = t4_write_page_pods_for_buf(sc, toep->ofld_txq, toep->tid, prsv,
 849             (vm_offset_t)csio->data_ptr, csio->dxfer_len);
 850         if (rc != 0) {
 851                 t4_free_page_pods(prsv);
 852                 uma_zfree(prsv_zone, prsv);
 853                 goto no_ddp;
 854         }
 855
 856         *ittp = htobe32(prsv->prsv_tag);
 857         *arg = prsv;
 858         counter_u64_add(ci->ddp_setup_ok, 1);
 859         return (0);
 860 }
 861
 862 void
 863 icl_cxgbei_conn_task_done(struct icl_conn *ic, void *arg)
 864 {
 865
 866         if (arg != NULL) {
 867                 struct ppod_reservation *prsv = arg;
 868
 869                 t4_free_page_pods(prsv);
 870                 uma_zfree(prsv_zone, prsv);
 871         }
 872 }
 873
 874 /* XXXNP: PDU should be passed in as parameter, like on the initiator. */
 875 #define io_to_request_pdu(io) ((io)->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr)
 876 #define io_to_ppod_reservation(io) ((io)->io_hdr.ctl_private[CTL_PRIV_FRONTEND2].ptr)
 877
 878 int
 879 icl_cxgbei_conn_transfer_setup(struct icl_conn *ic, union ctl_io *io,
 880     uint32_t *tttp, void **arg)
 881 {
 882         struct icl_cxgbei_conn *icc = ic_to_icc(ic);
 883         struct toepcb *toep = icc->toep;
 884         struct ctl_scsiio *ctsio = &io->scsiio;
 885         struct adapter *sc = icc->sc;
 886         struct cxgbei_data *ci = sc->iscsi_ulp_softc;
 887         struct ppod_region *pr = &ci->pr;
 888         struct ppod_reservation *prsv;
 889         uint32_t ttt;
 890         int xferlen, rc = 0, alias;
 891
 892         /* This is for the offload driver's state.  Must not be set already. */
 893         MPASS(arg != NULL);
 894         MPASS(*arg == NULL);
 895
 896         if (ctsio->ext_data_filled == 0) {
 897                 int first_burst;
 898                 struct icl_pdu *ip = io_to_request_pdu(io);
 899                 vm_offset_t buf;
 900 #ifdef INVARIANTS
 901                 struct icl_cxgbei_pdu *icp = ip_to_icp(ip);
 902
 903                 MPASS(icp->icp_signature == CXGBEI_PDU_SIGNATURE);
 904                 MPASS(ic == ip->ip_conn);
 905                 MPASS(ip->ip_bhs_mbuf != NULL);
 906 #endif
 907                 first_burst = icl_pdu_data_segment_length(ip);
 908
 909                 /*
 910                  * Note that ICL calls conn_transfer_setup even if the first
 911                  * burst had everything and there's nothing left to transfer.
 912                  */
 913                 MPASS(ctsio->kern_data_len >= first_burst);
 914                 xferlen = ctsio->kern_data_len;
 915                 if (xferlen - first_burst < ci->ddp_threshold) {
 916 no_ddp:
 917                         /*
 918                          * No DDP for this transfer.  Allocate a TTT (based on
 919                          * the one passed in) that cannot be a valid hardware
 920                          * DDP tag in the iSCSI region.
 921                          */
 922                         ttt = *tttp & M_PPOD_TAG;
 923                         ttt = V_PPOD_TAG(ttt) | pr->pr_invalid_bit;
 924                         *tttp = htobe32(ttt);
 925                         MPASS(io_to_ppod_reservation(io) == NULL);
 926                         if (rc != 0)
 927                                 counter_u64_add(ci->ddp_setup_error, 1);
 928                         return (0);
 929                 }
 930
 931                 if (ctsio->kern_sg_entries == 0)
 932                         buf = (vm_offset_t)ctsio->kern_data_ptr;
 933                 else if (ctsio->kern_sg_entries == 1) {
 934                         struct ctl_sg_entry *sgl = (void *)ctsio->kern_data_ptr;
 935
 936                         MPASS(sgl->len == xferlen);
 937                         buf = (vm_offset_t)sgl->addr;
 938                 } else {
 939                         rc = EAGAIN;    /* XXX implement */
 940                         goto no_ddp;
 941                 }
 942
 943
 944                 /*
 945                  * Reserve resources for DDP, update the ttt that should be used
 946                  * in the PDU, and save DDP specific state for this I/O.
 947                  */
 948
 949                 MPASS(io_to_ppod_reservation(io) == NULL);
 950                 prsv = uma_zalloc(prsv_zone, M_NOWAIT);
 951                 if (prsv == NULL) {
 952                         rc = ENOMEM;
 953                         goto no_ddp;
 954                 }
 955
 956                 rc = t4_alloc_page_pods_for_buf(pr, buf, xferlen, prsv);
 957                 if (rc != 0) {
 958                         uma_zfree(prsv_zone, prsv);
 959                         goto no_ddp;
 960                 }
 961
 962                 rc = t4_write_page_pods_for_buf(sc, toep->ofld_txq, toep->tid,
 963                     prsv, buf, xferlen);
 964                 if (rc != 0) {
 965                         t4_free_page_pods(prsv);
 966                         uma_zfree(prsv_zone, prsv);
 967                         goto no_ddp;
 968                 }
 969
 970                 *tttp = htobe32(prsv->prsv_tag);
 971                 io_to_ppod_reservation(io) = prsv;
 972                 *arg = ctsio;
 973                 counter_u64_add(ci->ddp_setup_ok, 1);
 974                 return (0);
 975         }
 976
 977         /*
 978          * In the middle of an I/O.  A non-NULL page pod reservation indicates
 979          * that a DDP buffer is being used for the I/O.
 980          */
 981
 982         prsv = io_to_ppod_reservation(ctsio);
 983         if (prsv == NULL)
 984                 goto no_ddp;
 985
 986         alias = (prsv->prsv_tag & pr->pr_alias_mask) >> pr->pr_alias_shift;
 987         alias++;
 988         prsv->prsv_tag &= ~pr->pr_alias_mask;
 989         prsv->prsv_tag |= alias << pr->pr_alias_shift & pr->pr_alias_mask;
 990
 991         *tttp = htobe32(prsv->prsv_tag);
 992         *arg = ctsio;
 993
 994         return (0);
 995 }
 996
 997 void
 998 icl_cxgbei_conn_transfer_done(struct icl_conn *ic, void *arg)
 999 {
1000         struct ctl_scsiio *ctsio = arg;
1001
1002         if (ctsio != NULL && ctsio->kern_data_len == ctsio->ext_data_filled) {
1003                 struct ppod_reservation *prsv;
1004
1005                 prsv = io_to_ppod_reservation(ctsio);
1006                 MPASS(prsv != NULL);
1007
1008                 t4_free_page_pods(prsv);
1009                 uma_zfree(prsv_zone, prsv);
1010         }
1011 }
1012
1013 static void
1014 cxgbei_limits(struct adapter *sc, void *arg)
1015 {
1016         struct icl_drv_limits *idl = arg;
1017         struct cxgbei_data *ci;
1018         int max_dsl;
1019
1020         if (begin_synchronized_op(sc, NULL, HOLD_LOCK, "t4lims") != 0)
1021                 return;
1022
1023         if (uld_active(sc, ULD_ISCSI)) {
1024                 ci = sc->iscsi_ulp_softc;
1025                 MPASS(ci != NULL);
1026
1027                 /*
1028                  * AHS is not supported by the kernel so we'll not account for
1029                  * it either in our PDU len -> data segment len conversions.
1030                  */
1031
1032                 max_dsl = ci->max_rx_pdu_len - ISCSI_BHS_SIZE -
1033                     ISCSI_HEADER_DIGEST_SIZE - ISCSI_DATA_DIGEST_SIZE;
1034                 if (idl->idl_max_recv_data_segment_length > max_dsl)
1035                         idl->idl_max_recv_data_segment_length = max_dsl;
1036
1037                 max_dsl = ci->max_tx_pdu_len - ISCSI_BHS_SIZE -
1038                     ISCSI_HEADER_DIGEST_SIZE - ISCSI_DATA_DIGEST_SIZE;
1039                 if (idl->idl_max_send_data_segment_length > max_dsl)
1040                         idl->idl_max_send_data_segment_length = max_dsl;
1041         }
1042
1043         end_synchronized_op(sc, LOCK_HELD);
1044 }
1045
1046 static int
1047 icl_cxgbei_limits(struct icl_drv_limits *idl)
1048 {
1049
1050         /* Maximum allowed by the RFC.  cxgbei_limits will clip them. */
1051         idl->idl_max_recv_data_segment_length = (1 << 24) - 1;
1052         idl->idl_max_send_data_segment_length = (1 << 24) - 1;
1053
1054         /* These are somewhat arbitrary. */
1055         idl->idl_max_burst_length = 2 * 1024 * 1024;
1056         idl->idl_first_burst_length = 8192;
1057
1058         t4_iterate(cxgbei_limits, idl);
1059
1060         return (0);
1061 }
1062
1063 int
1064 icl_cxgbei_mod_load(void)
1065 {
1066         int rc;
1067
1068         /*
1069          * Space to track pagepod reservations.
1070          */
1071         prsv_zone = uma_zcreate("Pagepod reservations",
1072             sizeof(struct ppod_reservation), NULL, NULL, NULL, NULL,
1073             UMA_ALIGN_CACHE, 0);
1074
1075         refcount_init(&icl_cxgbei_ncons, 0);
1076
1077         rc = icl_register("cxgbei", false, -100, icl_cxgbei_limits,
1078             icl_cxgbei_new_conn);
1079
1080         return (rc);
1081 }
1082
1083 int
1084 icl_cxgbei_mod_unload(void)
1085 {
1086
1087         if (icl_cxgbei_ncons != 0)
1088                 return (EBUSY);
1089
1090         icl_unregister("cxgbei", false);
1091
1092         uma_zdestroy(prsv_zone);
1093
1094         return (0);
1095 }
1096 #endif