sys/cam/ctl/ctl_ha.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2015 Alexander Motin <mav@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer,
  12  *    without modification, immediately at the beginning of the file.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/condvar.h>
  34 #include <sys/conf.h>
  35 #include <sys/eventhandler.h>
  36 #include <sys/kernel.h>
  37 #include <sys/kthread.h>
  38 #include <sys/limits.h>
  39 #include <sys/lock.h>
  40 #include <sys/malloc.h>
  41 #include <sys/mbuf.h>
  42 #include <sys/module.h>
  43 #include <sys/mutex.h>
  44 #include <sys/proc.h>
  45 #include <sys/queue.h>
  46 #include <sys/socket.h>
  47 #include <sys/socketvar.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/systm.h>
  50 #include <sys/uio.h>
  51 #include <netinet/in.h>
  52 #include <netinet/tcp.h>
  53 #include <vm/uma.h>
  54
  55 #include <cam/cam.h>
  56 #include <cam/scsi/scsi_all.h>
  57 #include <cam/scsi/scsi_da.h>
  58 #include <cam/ctl/ctl_io.h>
  59 #include <cam/ctl/ctl.h>
  60 #include <cam/ctl/ctl_frontend.h>
  61 #include <cam/ctl/ctl_util.h>
  62 #include <cam/ctl/ctl_backend.h>
  63 #include <cam/ctl/ctl_ioctl.h>
  64 #include <cam/ctl/ctl_ha.h>
  65 #include <cam/ctl/ctl_private.h>
  66 #include <cam/ctl/ctl_debug.h>
  67 #include <cam/ctl/ctl_error.h>
  68
  69 #if (__FreeBSD_version < 1100000)
  70 struct mbufq {
  71         struct mbuf *head;
  72         struct mbuf *tail;
  73 };
  74
  75 static void
  76 mbufq_init(struct mbufq *q, int limit)
  77 {
  78
  79         q->head = q->tail = NULL;
  80 }
  81
  82 static void
  83 mbufq_drain(struct mbufq *q)
  84 {
  85         struct mbuf *m;
  86
  87         while ((m = q->head) != NULL) {
  88                 q->head = m->m_nextpkt;
  89                 m_freem(m);
  90         }
  91         q->tail = NULL;
  92 }
  93
  94 static struct mbuf *
  95 mbufq_dequeue(struct mbufq *q)
  96 {
  97         struct mbuf *m;
  98
  99         m = q->head;
 100         if (m) {
 101                 if (q->tail == m)
 102                         q->tail = NULL;
 103                 q->head = m->m_nextpkt;
 104                 m->m_nextpkt = NULL;
 105         }
 106         return (m);
 107 }
 108
 109 static void
 110 mbufq_enqueue(struct mbufq *q, struct mbuf *m)
 111 {
 112
 113         m->m_nextpkt = NULL;
 114         if (q->tail)
 115                 q->tail->m_nextpkt = m;
 116         else
 117                 q->head = m;
 118         q->tail = m;
 119 }
 120
 121 static u_int
 122 sbavail(struct sockbuf *sb)
 123 {
 124         return (sb->sb_cc);
 125 }
 126
 127 #if (__FreeBSD_version < 1000000)
 128 #define mtodo(m, o)     ((void *)(((m)->m_data) + (o)))
 129 #endif
 130 #endif
 131
 132 struct ha_msg_wire {
 133         uint32_t         channel;
 134         uint32_t         length;
 135 };
 136
 137 struct ha_dt_msg_wire {
 138         ctl_ha_dt_cmd   command;
 139         uint32_t        size;
 140         uint8_t         *local;
 141         uint8_t         *remote;
 142 };
 143
 144 struct ha_softc {
 145         struct ctl_softc *ha_ctl_softc;
 146         ctl_evt_handler  ha_handler[CTL_HA_CHAN_MAX];
 147         char             ha_peer[128];
 148         struct sockaddr_in  ha_peer_in;
 149         struct socket   *ha_lso;
 150         struct socket   *ha_so;
 151         struct mbufq     ha_sendq;
 152         struct mbuf     *ha_sending;
 153         struct mtx       ha_lock;
 154         int              ha_connect;
 155         int              ha_listen;
 156         int              ha_connected;
 157         int              ha_receiving;
 158         int              ha_wakeup;
 159         int              ha_disconnect;
 160         int              ha_shutdown;
 161         eventhandler_tag ha_shutdown_eh;
 162         TAILQ_HEAD(, ctl_ha_dt_req) ha_dts;
 163 } ha_softc;
 164
 165 static void
 166 ctl_ha_conn_wake(struct ha_softc *softc)
 167 {
 168
 169         mtx_lock(&softc->ha_lock);
 170         softc->ha_wakeup = 1;
 171         mtx_unlock(&softc->ha_lock);
 172         wakeup(&softc->ha_wakeup);
 173 }
 174
 175 static int
 176 ctl_ha_lupcall(struct socket *so, void *arg, int waitflag)
 177 {
 178         struct ha_softc *softc = arg;
 179
 180         ctl_ha_conn_wake(softc);
 181         return (SU_OK);
 182 }
 183
 184 static int
 185 ctl_ha_rupcall(struct socket *so, void *arg, int waitflag)
 186 {
 187         struct ha_softc *softc = arg;
 188
 189         wakeup(&softc->ha_receiving);
 190         return (SU_OK);
 191 }
 192
 193 static int
 194 ctl_ha_supcall(struct socket *so, void *arg, int waitflag)
 195 {
 196         struct ha_softc *softc = arg;
 197
 198         ctl_ha_conn_wake(softc);
 199         return (SU_OK);
 200 }
 201
 202 static void
 203 ctl_ha_evt(struct ha_softc *softc, ctl_ha_channel ch, ctl_ha_event evt,
 204     int param)
 205 {
 206         int i;
 207
 208         if (ch < CTL_HA_CHAN_MAX) {
 209                 if (softc->ha_handler[ch])
 210                         softc->ha_handler[ch](ch, evt, param);
 211                 return;
 212         }
 213         for (i = 0; i < CTL_HA_CHAN_MAX; i++) {
 214                 if (softc->ha_handler[i])
 215                         softc->ha_handler[i](i, evt, param);
 216         }
 217 }
 218
 219 static void
 220 ctl_ha_close(struct ha_softc *softc)
 221 {
 222         struct socket *so = softc->ha_so;
 223         int report = 0;
 224
 225         if (softc->ha_connected || softc->ha_disconnect) {
 226                 softc->ha_connected = 0;
 227                 mbufq_drain(&softc->ha_sendq);
 228                 m_freem(softc->ha_sending);
 229                 softc->ha_sending = NULL;
 230                 report = 1;
 231         }
 232         if (so) {
 233                 SOCKBUF_LOCK(&so->so_rcv);
 234                 soupcall_clear(so, SO_RCV);
 235                 while (softc->ha_receiving) {
 236                         wakeup(&softc->ha_receiving);
 237                         msleep(&softc->ha_receiving, SOCKBUF_MTX(&so->so_rcv),
 238                             0, "ha_rx exit", 0);
 239                 }
 240                 SOCKBUF_UNLOCK(&so->so_rcv);
 241                 SOCKBUF_LOCK(&so->so_snd);
 242                 soupcall_clear(so, SO_SND);
 243                 SOCKBUF_UNLOCK(&so->so_snd);
 244                 softc->ha_so = NULL;
 245                 if (softc->ha_connect)
 246                         pause("reconnect", hz / 2);
 247                 soclose(so);
 248         }
 249         if (report) {
 250                 ctl_ha_evt(softc, CTL_HA_CHAN_MAX, CTL_HA_EVT_LINK_CHANGE,
 251                     (softc->ha_connect || softc->ha_listen) ?
 252                     CTL_HA_LINK_UNKNOWN : CTL_HA_LINK_OFFLINE);
 253         }
 254 }
 255
 256 static void
 257 ctl_ha_lclose(struct ha_softc *softc)
 258 {
 259
 260         if (softc->ha_lso) {
 261                 SOCKBUF_LOCK(&softc->ha_lso->so_rcv);
 262                 soupcall_clear(softc->ha_lso, SO_RCV);
 263                 SOCKBUF_UNLOCK(&softc->ha_lso->so_rcv);
 264                 soclose(softc->ha_lso);
 265                 softc->ha_lso = NULL;
 266         }
 267 }
 268
 269 static void
 270 ctl_ha_rx_thread(void *arg)
 271 {
 272         struct ha_softc *softc = arg;
 273         struct socket *so = softc->ha_so;
 274         struct ha_msg_wire wire_hdr;
 275         struct uio uio;
 276         struct iovec iov;
 277         int error, flags, next;
 278
 279         bzero(&wire_hdr, sizeof(wire_hdr));
 280         while (1) {
 281                 if (wire_hdr.length > 0)
 282                         next = wire_hdr.length;
 283                 else
 284                         next = sizeof(wire_hdr);
 285                 SOCKBUF_LOCK(&so->so_rcv);
 286                 while (sbavail(&so->so_rcv) < next || softc->ha_disconnect) {
 287                         if (softc->ha_connected == 0 || softc->ha_disconnect ||
 288                             so->so_error ||
 289                             (so->so_rcv.sb_state & SBS_CANTRCVMORE)) {
 290                                 goto errout;
 291                         }
 292                         so->so_rcv.sb_lowat = next;
 293                         msleep(&softc->ha_receiving, SOCKBUF_MTX(&so->so_rcv),
 294                             0, "-", 0);
 295                 }
 296                 SOCKBUF_UNLOCK(&so->so_rcv);
 297
 298                 if (wire_hdr.length == 0) {
 299                         iov.iov_base = &wire_hdr;
 300                         iov.iov_len = sizeof(wire_hdr);
 301                         uio.uio_iov = &iov;
 302                         uio.uio_iovcnt = 1;
 303                         uio.uio_rw = UIO_READ;
 304                         uio.uio_segflg = UIO_SYSSPACE;
 305                         uio.uio_td = curthread;
 306                         uio.uio_resid = sizeof(wire_hdr);
 307                         flags = MSG_DONTWAIT;
 308                         error = soreceive(softc->ha_so, NULL, &uio, NULL,
 309                             NULL, &flags);
 310                         if (error != 0) {
 311                                 printf("%s: header receive error %d\n",
 312                                     __func__, error);
 313                                 SOCKBUF_LOCK(&so->so_rcv);
 314                                 goto errout;
 315                         }
 316                 } else {
 317                         ctl_ha_evt(softc, wire_hdr.channel,
 318                             CTL_HA_EVT_MSG_RECV, wire_hdr.length);
 319                         wire_hdr.length = 0;
 320                 }
 321         }
 322
 323 errout:
 324         softc->ha_receiving = 0;
 325         wakeup(&softc->ha_receiving);
 326         SOCKBUF_UNLOCK(&so->so_rcv);
 327         ctl_ha_conn_wake(softc);
 328         kthread_exit();
 329 }
 330
 331 static void
 332 ctl_ha_send(struct ha_softc *softc)
 333 {
 334         struct socket *so = softc->ha_so;
 335         int error;
 336
 337         while (1) {
 338                 if (softc->ha_sending == NULL) {
 339                         mtx_lock(&softc->ha_lock);
 340                         softc->ha_sending = mbufq_dequeue(&softc->ha_sendq);
 341                         mtx_unlock(&softc->ha_lock);
 342                         if (softc->ha_sending == NULL) {
 343                                 so->so_snd.sb_lowat = so->so_snd.sb_hiwat + 1;
 344                                 break;
 345                         }
 346                 }
 347                 SOCKBUF_LOCK(&so->so_snd);
 348                 if (sbspace(&so->so_snd) < softc->ha_sending->m_pkthdr.len) {
 349                         so->so_snd.sb_lowat = softc->ha_sending->m_pkthdr.len;
 350                         SOCKBUF_UNLOCK(&so->so_snd);
 351                         break;
 352                 }
 353                 SOCKBUF_UNLOCK(&so->so_snd);
 354                 error = sosend(softc->ha_so, NULL, NULL, softc->ha_sending,
 355                     NULL, MSG_DONTWAIT, curthread);
 356                 softc->ha_sending = NULL;
 357                 if (error != 0) {
 358                         printf("%s: sosend() error %d\n", __func__, error);
 359                         return;
 360                 }
 361         }
 362 }
 363
 364 static void
 365 ctl_ha_sock_setup(struct ha_softc *softc)
 366 {
 367         struct sockopt opt;
 368         struct socket *so = softc->ha_so;
 369         int error, val;
 370
 371         val = 1024 * 1024;
 372         error = soreserve(so, val, val);
 373         if (error)
 374                 printf("%s: soreserve failed %d\n", __func__, error);
 375
 376         SOCKBUF_LOCK(&so->so_rcv);
 377         so->so_rcv.sb_lowat = sizeof(struct ha_msg_wire);
 378         soupcall_set(so, SO_RCV, ctl_ha_rupcall, softc);
 379         SOCKBUF_UNLOCK(&so->so_rcv);
 380         SOCKBUF_LOCK(&so->so_snd);
 381         so->so_snd.sb_lowat = sizeof(struct ha_msg_wire);
 382         soupcall_set(so, SO_SND, ctl_ha_supcall, softc);
 383         SOCKBUF_UNLOCK(&so->so_snd);
 384
 385         bzero(&opt, sizeof(struct sockopt));
 386         opt.sopt_dir = SOPT_SET;
 387         opt.sopt_level = SOL_SOCKET;
 388         opt.sopt_name = SO_KEEPALIVE;
 389         opt.sopt_val = &val;
 390         opt.sopt_valsize = sizeof(val);
 391         val = 1;
 392         error = sosetopt(so, &opt);
 393         if (error)
 394                 printf("%s: KEEPALIVE setting failed %d\n", __func__, error);
 395
 396         opt.sopt_level = IPPROTO_TCP;
 397         opt.sopt_name = TCP_NODELAY;
 398         val = 1;
 399         error = sosetopt(so, &opt);
 400         if (error)
 401                 printf("%s: NODELAY setting failed %d\n", __func__, error);
 402
 403         opt.sopt_name = TCP_KEEPINIT;
 404         val = 3;
 405         error = sosetopt(so, &opt);
 406         if (error)
 407                 printf("%s: KEEPINIT setting failed %d\n", __func__, error);
 408
 409         opt.sopt_name = TCP_KEEPIDLE;
 410         val = 1;
 411         error = sosetopt(so, &opt);
 412         if (error)
 413                 printf("%s: KEEPIDLE setting failed %d\n", __func__, error);
 414
 415         opt.sopt_name = TCP_KEEPINTVL;
 416         val = 1;
 417         error = sosetopt(so, &opt);
 418         if (error)
 419                 printf("%s: KEEPINTVL setting failed %d\n", __func__, error);
 420
 421         opt.sopt_name = TCP_KEEPCNT;
 422         val = 5;
 423         error = sosetopt(so, &opt);
 424         if (error)
 425                 printf("%s: KEEPCNT setting failed %d\n", __func__, error);
 426 }
 427
 428 static int
 429 ctl_ha_connect(struct ha_softc *softc)
 430 {
 431         struct thread *td = curthread;
 432         struct sockaddr_in sa;
 433         struct socket *so;
 434         int error;
 435
 436         /* Create the socket */
 437         error = socreate(PF_INET, &so, SOCK_STREAM,
 438             IPPROTO_TCP, td->td_ucred, td);
 439         if (error != 0) {
 440                 printf("%s: socreate() error %d\n", __func__, error);
 441                 return (error);
 442         }
 443         softc->ha_so = so;
 444         ctl_ha_sock_setup(softc);
 445
 446         memcpy(&sa, &softc->ha_peer_in, sizeof(sa));
 447         error = soconnect(so, (struct sockaddr *)&sa, td);
 448         if (error != 0) {
 449                 if (bootverbose)
 450                         printf("%s: soconnect() error %d\n", __func__, error);
 451                 goto out;
 452         }
 453         return (0);
 454
 455 out:
 456         ctl_ha_close(softc);
 457         return (error);
 458 }
 459
 460 static int
 461 ctl_ha_accept(struct ha_softc *softc)
 462 {
 463         struct socket *lso, *so;
 464         struct sockaddr *sap;
 465         int error;
 466
 467         lso = softc->ha_lso;
 468         SOLISTEN_LOCK(lso);
 469         error = solisten_dequeue(lso, &so, 0);
 470         if (error == EWOULDBLOCK)
 471                 return (error);
 472         if (error) {
 473                 printf("%s: socket error %d\n", __func__, error);
 474                 goto out;
 475         }
 476
 477         sap = NULL;
 478         error = soaccept(so, &sap);
 479         if (error != 0) {
 480                 printf("%s: soaccept() error %d\n", __func__, error);
 481                 if (sap != NULL)
 482                         free(sap, M_SONAME);
 483                 goto out;
 484         }
 485         if (sap != NULL)
 486                 free(sap, M_SONAME);
 487         softc->ha_so = so;
 488         ctl_ha_sock_setup(softc);
 489         return (0);
 490
 491 out:
 492         ctl_ha_lclose(softc);
 493         return (error);
 494 }
 495
 496 static int
 497 ctl_ha_listen(struct ha_softc *softc)
 498 {
 499         struct thread *td = curthread;
 500         struct sockaddr_in sa;
 501         struct sockopt opt;
 502         int error, val;
 503
 504         /* Create the socket */
 505         if (softc->ha_lso == NULL) {
 506                 error = socreate(PF_INET, &softc->ha_lso, SOCK_STREAM,
 507                     IPPROTO_TCP, td->td_ucred, td);
 508                 if (error != 0) {
 509                         printf("%s: socreate() error %d\n", __func__, error);
 510                         return (error);
 511                 }
 512                 bzero(&opt, sizeof(struct sockopt));
 513                 opt.sopt_dir = SOPT_SET;
 514                 opt.sopt_level = SOL_SOCKET;
 515                 opt.sopt_name = SO_REUSEADDR;
 516                 opt.sopt_val = &val;
 517                 opt.sopt_valsize = sizeof(val);
 518                 val = 1;
 519                 error = sosetopt(softc->ha_lso, &opt);
 520                 if (error) {
 521                         printf("%s: REUSEADDR setting failed %d\n",
 522                             __func__, error);
 523                 }
 524                 bzero(&opt, sizeof(struct sockopt));
 525                 opt.sopt_dir = SOPT_SET;
 526                 opt.sopt_level = SOL_SOCKET;
 527                 opt.sopt_name = SO_REUSEPORT;
 528                 opt.sopt_val = &val;
 529                 opt.sopt_valsize = sizeof(val);
 530                 val = 1;
 531                 error = sosetopt(softc->ha_lso, &opt);
 532                 if (error) {
 533                         printf("%s: REUSEPORT setting failed %d\n",
 534                             __func__, error);
 535                 }
 536         }
 537
 538         memcpy(&sa, &softc->ha_peer_in, sizeof(sa));
 539         error = sobind(softc->ha_lso, (struct sockaddr *)&sa, td);
 540         if (error != 0) {
 541                 printf("%s: sobind() error %d\n", __func__, error);
 542                 goto out;
 543         }
 544         error = solisten(softc->ha_lso, 1, td);
 545         if (error != 0) {
 546                 printf("%s: solisten() error %d\n", __func__, error);
 547                 goto out;
 548         }
 549         SOLISTEN_LOCK(softc->ha_lso);
 550         softc->ha_lso->so_state |= SS_NBIO;
 551         solisten_upcall_set(softc->ha_lso, ctl_ha_lupcall, softc);
 552         SOLISTEN_UNLOCK(softc->ha_lso);
 553         return (0);
 554
 555 out:
 556         ctl_ha_lclose(softc);
 557         return (error);
 558 }
 559
 560 static void
 561 ctl_ha_conn_thread(void *arg)
 562 {
 563         struct ha_softc *softc = arg;
 564         int error;
 565
 566         while (1) {
 567                 if (softc->ha_disconnect || softc->ha_shutdown) {
 568                         ctl_ha_close(softc);
 569                         if (softc->ha_disconnect == 2 || softc->ha_shutdown)
 570                                 ctl_ha_lclose(softc);
 571                         softc->ha_disconnect = 0;
 572                         if (softc->ha_shutdown)
 573                                 break;
 574                 } else if (softc->ha_so != NULL &&
 575                     (softc->ha_so->so_error ||
 576                      softc->ha_so->so_rcv.sb_state & SBS_CANTRCVMORE))
 577                         ctl_ha_close(softc);
 578                 if (softc->ha_so == NULL) {
 579                         if (softc->ha_lso != NULL)
 580                                 ctl_ha_accept(softc);
 581                         else if (softc->ha_listen)
 582                                 ctl_ha_listen(softc);
 583                         else if (softc->ha_connect)
 584                                 ctl_ha_connect(softc);
 585                 }
 586                 if (softc->ha_so != NULL) {
 587                         if (softc->ha_connected == 0 &&
 588                             softc->ha_so->so_error == 0 &&
 589                             (softc->ha_so->so_state & SS_ISCONNECTING) == 0) {
 590                                 softc->ha_connected = 1;
 591                                 ctl_ha_evt(softc, CTL_HA_CHAN_MAX,
 592                                     CTL_HA_EVT_LINK_CHANGE,
 593                                     CTL_HA_LINK_ONLINE);
 594                                 softc->ha_receiving = 1;
 595                                 error = kproc_kthread_add(ctl_ha_rx_thread,
 596                                     softc, &softc->ha_ctl_softc->ctl_proc,
 597                                     NULL, 0, 0, "ctl", "ha_rx");
 598                                 if (error != 0) {
 599                                         printf("Error creating CTL HA rx thread!\n");
 600                                         softc->ha_receiving = 0;
 601                                         softc->ha_disconnect = 1;
 602                                 }
 603                         }
 604                         ctl_ha_send(softc);
 605                 }
 606                 mtx_lock(&softc->ha_lock);
 607                 if (softc->ha_so != NULL &&
 608                     (softc->ha_so->so_error ||
 609                      softc->ha_so->so_rcv.sb_state & SBS_CANTRCVMORE))
 610                         ;
 611                 else if (!softc->ha_wakeup)
 612                         msleep(&softc->ha_wakeup, &softc->ha_lock, 0, "-", hz);
 613                 softc->ha_wakeup = 0;
 614                 mtx_unlock(&softc->ha_lock);
 615         }
 616         mtx_lock(&softc->ha_lock);
 617         softc->ha_shutdown = 2;
 618         wakeup(&softc->ha_wakeup);
 619         mtx_unlock(&softc->ha_lock);
 620         kthread_exit();
 621 }
 622
 623 static int
 624 ctl_ha_peer_sysctl(SYSCTL_HANDLER_ARGS)
 625 {
 626         struct ha_softc *softc = (struct ha_softc *)arg1;
 627         struct sockaddr_in *sa;
 628         int error, b1, b2, b3, b4, p, num;
 629         char buf[128];
 630
 631         strlcpy(buf, softc->ha_peer, sizeof(buf));
 632         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 633         if ((error != 0) || (req->newptr == NULL) ||
 634             strncmp(buf, softc->ha_peer, sizeof(buf)) == 0)
 635                 return (error);
 636
 637         sa = &softc->ha_peer_in;
 638         mtx_lock(&softc->ha_lock);
 639         if ((num = sscanf(buf, "connect %d.%d.%d.%d:%d",
 640             &b1, &b2, &b3, &b4, &p)) >= 4) {
 641                 softc->ha_connect = 1;
 642                 softc->ha_listen = 0;
 643         } else if ((num = sscanf(buf, "listen %d.%d.%d.%d:%d",
 644             &b1, &b2, &b3, &b4, &p)) >= 4) {
 645                 softc->ha_connect = 0;
 646                 softc->ha_listen = 1;
 647         } else {
 648                 softc->ha_connect = 0;
 649                 softc->ha_listen = 0;
 650                 if (buf[0] != 0) {
 651                         buf[0] = 0;
 652                         error = EINVAL;
 653                 }
 654         }
 655         strlcpy(softc->ha_peer, buf, sizeof(softc->ha_peer));
 656         if (softc->ha_connect || softc->ha_listen) {
 657                 memset(sa, 0, sizeof(*sa));
 658                 sa->sin_len = sizeof(struct sockaddr_in);
 659                 sa->sin_family = AF_INET;
 660                 sa->sin_port = htons((num >= 5) ? p : 999);
 661                 sa->sin_addr.s_addr =
 662                     htonl((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
 663         }
 664         softc->ha_disconnect = 2;
 665         softc->ha_wakeup = 1;
 666         mtx_unlock(&softc->ha_lock);
 667         wakeup(&softc->ha_wakeup);
 668         return (error);
 669 }
 670
 671 ctl_ha_status
 672 ctl_ha_msg_register(ctl_ha_channel channel, ctl_evt_handler handler)
 673 {
 674         struct ha_softc *softc = &ha_softc;
 675
 676         KASSERT(channel < CTL_HA_CHAN_MAX,
 677             ("Wrong CTL HA channel %d", channel));
 678         softc->ha_handler[channel] = handler;
 679         return (CTL_HA_STATUS_SUCCESS);
 680 }
 681
 682 ctl_ha_status
 683 ctl_ha_msg_deregister(ctl_ha_channel channel)
 684 {
 685         struct ha_softc *softc = &ha_softc;
 686
 687         KASSERT(channel < CTL_HA_CHAN_MAX,
 688             ("Wrong CTL HA channel %d", channel));
 689         softc->ha_handler[channel] = NULL;
 690         return (CTL_HA_STATUS_SUCCESS);
 691 }
 692
 693 /*
 694  * Receive a message of the specified size.
 695  */
 696 ctl_ha_status
 697 ctl_ha_msg_recv(ctl_ha_channel channel, void *addr, size_t len,
 698                 int wait)
 699 {
 700         struct ha_softc *softc = &ha_softc;
 701         struct uio uio;
 702         struct iovec iov;
 703         int error, flags;
 704
 705         if (!softc->ha_connected)
 706                 return (CTL_HA_STATUS_DISCONNECT);
 707
 708         iov.iov_base = addr;
 709         iov.iov_len = len;
 710         uio.uio_iov = &iov;
 711         uio.uio_iovcnt = 1;
 712         uio.uio_rw = UIO_READ;
 713         uio.uio_segflg = UIO_SYSSPACE;
 714         uio.uio_td = curthread;
 715         uio.uio_resid = len;
 716         flags = wait ? 0 : MSG_DONTWAIT;
 717         error = soreceive(softc->ha_so, NULL, &uio, NULL, NULL, &flags);
 718         if (error == 0)
 719                 return (CTL_HA_STATUS_SUCCESS);
 720
 721         /* Consider all errors fatal for HA sanity. */
 722         mtx_lock(&softc->ha_lock);
 723         if (softc->ha_connected) {
 724                 softc->ha_disconnect = 1;
 725                 softc->ha_wakeup = 1;
 726                 wakeup(&softc->ha_wakeup);
 727         }
 728         mtx_unlock(&softc->ha_lock);
 729         return (CTL_HA_STATUS_ERROR);
 730 }
 731
 732 /*
 733  * Send a message of the specified size.
 734  */
 735 ctl_ha_status
 736 ctl_ha_msg_send2(ctl_ha_channel channel, const void *addr, size_t len,
 737     const void *addr2, size_t len2, int wait)
 738 {
 739         struct ha_softc *softc = &ha_softc;
 740         struct mbuf *mb, *newmb;
 741         struct ha_msg_wire hdr;
 742         size_t copylen, off;
 743
 744         if (!softc->ha_connected)
 745                 return (CTL_HA_STATUS_DISCONNECT);
 746
 747         newmb = m_getm2(NULL, sizeof(hdr) + len + len2, wait, MT_DATA,
 748             M_PKTHDR);
 749         if (newmb == NULL) {
 750                 /* Consider all errors fatal for HA sanity. */
 751                 mtx_lock(&softc->ha_lock);
 752                 if (softc->ha_connected) {
 753                         softc->ha_disconnect = 1;
 754                         softc->ha_wakeup = 1;
 755                         wakeup(&softc->ha_wakeup);
 756                 }
 757                 mtx_unlock(&softc->ha_lock);
 758                 printf("%s: Can't allocate mbuf chain\n", __func__);
 759                 return (CTL_HA_STATUS_ERROR);
 760         }
 761         hdr.channel = channel;
 762         hdr.length = len + len2;
 763         mb = newmb;
 764         memcpy(mtodo(mb, 0), &hdr, sizeof(hdr));
 765         mb->m_len += sizeof(hdr);
 766         off = 0;
 767         for (; mb != NULL && off < len; mb = mb->m_next) {
 768                 copylen = min(M_TRAILINGSPACE(mb), len - off);
 769                 memcpy(mtodo(mb, mb->m_len), (const char *)addr + off, copylen);
 770                 mb->m_len += copylen;
 771                 off += copylen;
 772                 if (off == len)
 773                         break;
 774         }
 775         KASSERT(off == len, ("%s: off (%zu) != len (%zu)", __func__,
 776             off, len));
 777         off = 0;
 778         for (; mb != NULL && off < len2; mb = mb->m_next) {
 779                 copylen = min(M_TRAILINGSPACE(mb), len2 - off);
 780                 memcpy(mtodo(mb, mb->m_len), (const char *)addr2 + off, copylen);
 781                 mb->m_len += copylen;
 782                 off += copylen;
 783         }
 784         KASSERT(off == len2, ("%s: off (%zu) != len2 (%zu)", __func__,
 785             off, len2));
 786         newmb->m_pkthdr.len = sizeof(hdr) + len + len2;
 787
 788         mtx_lock(&softc->ha_lock);
 789         if (!softc->ha_connected) {
 790                 mtx_unlock(&softc->ha_lock);
 791                 m_freem(newmb);
 792                 return (CTL_HA_STATUS_DISCONNECT);
 793         }
 794         mbufq_enqueue(&softc->ha_sendq, newmb);
 795         softc->ha_wakeup = 1;
 796         mtx_unlock(&softc->ha_lock);
 797         wakeup(&softc->ha_wakeup);
 798         return (CTL_HA_STATUS_SUCCESS);
 799 }
 800
 801 ctl_ha_status
 802 ctl_ha_msg_send(ctl_ha_channel channel, const void *addr, size_t len,
 803     int wait)
 804 {
 805
 806         return (ctl_ha_msg_send2(channel, addr, len, NULL, 0, wait));
 807 }
 808
 809 ctl_ha_status
 810 ctl_ha_msg_abort(ctl_ha_channel channel)
 811 {
 812         struct ha_softc *softc = &ha_softc;
 813
 814         mtx_lock(&softc->ha_lock);
 815         softc->ha_disconnect = 1;
 816         softc->ha_wakeup = 1;
 817         mtx_unlock(&softc->ha_lock);
 818         wakeup(&softc->ha_wakeup);
 819         return (CTL_HA_STATUS_SUCCESS);
 820 }
 821
 822 /*
 823  * Allocate a data transfer request structure.
 824  */
 825 struct ctl_ha_dt_req *
 826 ctl_dt_req_alloc(void)
 827 {
 828
 829         return (malloc(sizeof(struct ctl_ha_dt_req), M_CTL, M_WAITOK | M_ZERO));
 830 }
 831
 832 /*
 833  * Free a data transfer request structure.
 834  */
 835 void
 836 ctl_dt_req_free(struct ctl_ha_dt_req *req)
 837 {
 838
 839         free(req, M_CTL);
 840 }
 841
 842 /*
 843  * Issue a DMA request for a single buffer.
 844  */
 845 ctl_ha_status
 846 ctl_dt_single(struct ctl_ha_dt_req *req)
 847 {
 848         struct ha_softc *softc = &ha_softc;
 849         struct ha_dt_msg_wire wire_dt;
 850         ctl_ha_status status;
 851
 852         wire_dt.command = req->command;
 853         wire_dt.size = req->size;
 854         wire_dt.local = req->local;
 855         wire_dt.remote = req->remote;
 856         if (req->command == CTL_HA_DT_CMD_READ && req->callback != NULL) {
 857                 mtx_lock(&softc->ha_lock);
 858                 TAILQ_INSERT_TAIL(&softc->ha_dts, req, links);
 859                 mtx_unlock(&softc->ha_lock);
 860                 ctl_ha_msg_send(CTL_HA_CHAN_DATA, &wire_dt, sizeof(wire_dt),
 861                     M_WAITOK);
 862                 return (CTL_HA_STATUS_WAIT);
 863         }
 864         if (req->command == CTL_HA_DT_CMD_READ) {
 865                 status = ctl_ha_msg_send(CTL_HA_CHAN_DATA, &wire_dt,
 866                     sizeof(wire_dt), M_WAITOK);
 867         } else {
 868                 status = ctl_ha_msg_send2(CTL_HA_CHAN_DATA, &wire_dt,
 869                     sizeof(wire_dt), req->local, req->size, M_WAITOK);
 870         }
 871         return (status);
 872 }
 873
 874 static void
 875 ctl_dt_event_handler(ctl_ha_channel channel, ctl_ha_event event, int param)
 876 {
 877         struct ha_softc *softc = &ha_softc;
 878         struct ctl_ha_dt_req *req;
 879         ctl_ha_status isc_status;
 880
 881         if (event == CTL_HA_EVT_MSG_RECV) {
 882                 struct ha_dt_msg_wire wire_dt;
 883                 uint8_t *tmp;
 884                 int size;
 885
 886                 size = min(sizeof(wire_dt), param);
 887                 isc_status = ctl_ha_msg_recv(CTL_HA_CHAN_DATA, &wire_dt,
 888                                              size, M_WAITOK);
 889                 if (isc_status != CTL_HA_STATUS_SUCCESS) {
 890                         printf("%s: Error receiving message: %d\n",
 891                             __func__, isc_status);
 892                         return;
 893                 }
 894
 895                 if (wire_dt.command == CTL_HA_DT_CMD_READ) {
 896                         wire_dt.command = CTL_HA_DT_CMD_WRITE;
 897                         tmp = wire_dt.local;
 898                         wire_dt.local = wire_dt.remote;
 899                         wire_dt.remote = tmp;
 900                         ctl_ha_msg_send2(CTL_HA_CHAN_DATA, &wire_dt,
 901                             sizeof(wire_dt), wire_dt.local, wire_dt.size,
 902                             M_WAITOK);
 903                 } else if (wire_dt.command == CTL_HA_DT_CMD_WRITE) {
 904                         isc_status = ctl_ha_msg_recv(CTL_HA_CHAN_DATA,
 905                             wire_dt.remote, wire_dt.size, M_WAITOK);
 906                         mtx_lock(&softc->ha_lock);
 907                         TAILQ_FOREACH(req, &softc->ha_dts, links) {
 908                                 if (req->local == wire_dt.remote) {
 909                                         TAILQ_REMOVE(&softc->ha_dts, req, links);
 910                                         break;
 911                                 }
 912                         }
 913                         mtx_unlock(&softc->ha_lock);
 914                         if (req) {
 915                                 req->ret = isc_status;
 916                                 req->callback(req);
 917                         }
 918                 }
 919         } else if (event == CTL_HA_EVT_LINK_CHANGE) {
 920                 CTL_DEBUG_PRINT(("%s: Link state change to %d\n", __func__,
 921                     param));
 922                 if (param != CTL_HA_LINK_ONLINE) {
 923                         mtx_lock(&softc->ha_lock);
 924                         while ((req = TAILQ_FIRST(&softc->ha_dts)) != NULL) {
 925                                 TAILQ_REMOVE(&softc->ha_dts, req, links);
 926                                 mtx_unlock(&softc->ha_lock);
 927                                 req->ret = CTL_HA_STATUS_DISCONNECT;
 928                                 req->callback(req);
 929                                 mtx_lock(&softc->ha_lock);
 930                         }
 931                         mtx_unlock(&softc->ha_lock);
 932                 }
 933         } else {
 934                 printf("%s: Unknown event %d\n", __func__, event);
 935         }
 936 }
 937
 938
 939 ctl_ha_status
 940 ctl_ha_msg_init(struct ctl_softc *ctl_softc)
 941 {
 942         struct ha_softc *softc = &ha_softc;
 943         int error;
 944
 945         softc->ha_ctl_softc = ctl_softc;
 946         mtx_init(&softc->ha_lock, "CTL HA mutex", NULL, MTX_DEF);
 947         mbufq_init(&softc->ha_sendq, INT_MAX);
 948         TAILQ_INIT(&softc->ha_dts);
 949         error = kproc_kthread_add(ctl_ha_conn_thread, softc,
 950             &ctl_softc->ctl_proc, NULL, 0, 0, "ctl", "ha_tx");
 951         if (error != 0) {
 952                 printf("error creating CTL HA connection thread!\n");
 953                 mtx_destroy(&softc->ha_lock);
 954                 return (CTL_HA_STATUS_ERROR);
 955         }
 956         softc->ha_shutdown_eh = EVENTHANDLER_REGISTER(shutdown_pre_sync,
 957             ctl_ha_msg_shutdown, ctl_softc, SHUTDOWN_PRI_FIRST);
 958         SYSCTL_ADD_PROC(&ctl_softc->sysctl_ctx,
 959             SYSCTL_CHILDREN(ctl_softc->sysctl_tree),
 960             OID_AUTO, "ha_peer", CTLTYPE_STRING | CTLFLAG_RWTUN,
 961             softc, 0, ctl_ha_peer_sysctl, "A", "HA peer connection method");
 962
 963         if (ctl_ha_msg_register(CTL_HA_CHAN_DATA, ctl_dt_event_handler)
 964             != CTL_HA_STATUS_SUCCESS) {
 965                 printf("%s: ctl_ha_msg_register failed.\n", __func__);
 966         }
 967
 968         return (CTL_HA_STATUS_SUCCESS);
 969 };
 970
 971 void
 972 ctl_ha_msg_shutdown(struct ctl_softc *ctl_softc)
 973 {
 974         struct ha_softc *softc = &ha_softc;
 975
 976         /* Disconnect and shutdown threads. */
 977         mtx_lock(&softc->ha_lock);
 978         if (softc->ha_shutdown < 2) {
 979                 softc->ha_shutdown = 1;
 980                 softc->ha_wakeup = 1;
 981                 wakeup(&softc->ha_wakeup);
 982                 while (softc->ha_shutdown < 2 && !SCHEDULER_STOPPED()) {
 983                         msleep(&softc->ha_wakeup, &softc->ha_lock, 0,
 984                             "shutdown", hz);
 985                 }
 986         }
 987         mtx_unlock(&softc->ha_lock);
 988 };
 989
 990 ctl_ha_status
 991 ctl_ha_msg_destroy(struct ctl_softc *ctl_softc)
 992 {
 993         struct ha_softc *softc = &ha_softc;
 994
 995         if (softc->ha_shutdown_eh != NULL) {
 996                 EVENTHANDLER_DEREGISTER(shutdown_pre_sync,
 997                     softc->ha_shutdown_eh);
 998                 softc->ha_shutdown_eh = NULL;
 999         }
1000
1001         ctl_ha_msg_shutdown(ctl_softc); /* Just in case. */
1002
1003         if (ctl_ha_msg_deregister(CTL_HA_CHAN_DATA) != CTL_HA_STATUS_SUCCESS)
1004                 printf("%s: ctl_ha_msg_deregister failed.\n", __func__);
1005
1006         mtx_destroy(&softc->ha_lock);
1007         return (CTL_HA_STATUS_SUCCESS);
1008 };