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