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