1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * DESCRIPTION 30 * 31 * ttymux_ioctl - Handler for ttymux specific ioctl calls. 32 * 33 */ 34 35 #include <sys/types.h> 36 #include <sys/strsubr.h> 37 #include <sys/strsun.h> 38 #include <sys/errno.h> 39 #include <sys/stat.h> 40 #include <sys/kmem.h> 41 #include <sys/ddi.h> 42 #include <sys/termio.h> 43 #include <sys/mkdev.h> 44 #include <sys/sunddi.h> 45 #include <sys/esunddi.h> 46 #include <sys/consdev.h> 47 #include <sys/promif.h> 48 49 #include <sys/ttymux.h> 50 #include "ttymux_impl.h" 51 52 /* 53 * Extern declarations 54 */ 55 extern mblk_t *mkiocb(uint_t); 56 extern int nulldev(); 57 extern uintptr_t space_fetch(char *key); 58 extern void prom_interpret(char *, uintptr_t, uintptr_t, uintptr_t, 59 uintptr_t, uintptr_t); 60 61 /* 62 * Imported ttymux routines 63 */ 64 extern void sm_debug(char *, ...); 65 extern void sm_log(char *, ...); 66 extern sm_lqi_t *get_lqi_byid(int); 67 extern sm_lqi_t *get_lqi_bydevt(dev_t); 68 extern int sm_associate(int, sm_lqi_t *, ulong_t, uint_t, char *); 69 extern int sm_disassociate(int, sm_lqi_t *, ulong_t); 70 71 /* 72 * Exported ttymux routines 73 */ 74 int ttymux_abort_ioctl(mblk_t *); 75 int ttymux_device_init(sm_lqi_t *); 76 int ttymux_device_fini(sm_lqi_t *); 77 int sm_ioctl_cmd(sm_uqi_t *, mblk_t *); 78 79 /* 80 * Imported ttymux variables 81 */ 82 extern sm_ss_t *sm_ssp; 83 84 static int 85 mblk2assoc(mblk_t *mp, ttymux_assoc_t *assoc) 86 { 87 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 88 89 sm_dbg('M', ("mblk2assoc:\n")); 90 if (mp->b_cont == NULL) 91 return (EINVAL); 92 93 #ifdef _SYSCALL32_IMPL 94 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 95 ttymux_assoc32_t *assoc32; 96 97 sm_dbg('I', ("mblk2assoc: b_cont 0x%p count %d (sz %d)\n", 98 mp->b_cont, iobp->ioc_count, sizeof (*assoc32))); 99 100 if (iobp->ioc_count < sizeof (ttymux_assoc32_t)) 101 return (EINVAL); 102 103 assoc32 = (ttymux_assoc32_t *)mp->b_cont->b_rptr; 104 assoc->ttymux_udev = expldev(assoc32->ttymux32_udev); 105 assoc->ttymux_ldev = expldev(assoc32->ttymux32_ldev); 106 assoc->ttymux_linkid = assoc32->ttymux32_linkid; 107 assoc->ttymux_tag = assoc32->ttymux32_tag; 108 assoc->ttymux_ioflag = assoc32->ttymux32_ioflag; 109 (void) strncpy(assoc->ttymux_path, assoc32->ttymux32_path, 110 MAXPATHLEN); 111 112 } else 113 #endif 114 if (iobp->ioc_count < sizeof (*assoc)) { 115 return (EINVAL); 116 } else { 117 *assoc = *(ttymux_assoc_t *)mp->b_cont->b_rptr; 118 } 119 sm_dbg('M', ("mblk2assoc (%d): dev %d:%d not found\n", 120 assoc->ttymux_linkid, getmajor(assoc->ttymux_ldev), 121 getminor(assoc->ttymux_ldev))); 122 return (0); 123 } 124 125 /* 126 * Given a device path return an OBP alias for it if it exists. 127 */ 128 static char * 129 val2alias(dnode_t node, char *path) 130 { 131 char *buf1; 132 char *buf2; 133 char *propname, *propval; 134 int proplen; 135 136 if (node == OBP_BADNODE) 137 return (NULL); 138 139 sm_dbg('A', ("Looking for an alias for: %s (len %d)\n", 140 path, strlen(path))); 141 142 /* 143 * Ask for first property by passing a NULL string 144 */ 145 buf1 = kmem_alloc(OBP_MAXPROPNAME, KM_SLEEP); 146 buf2 = kmem_zalloc(OBP_MAXPROPNAME, KM_SLEEP); 147 buf1[0] = '\0'; 148 149 while (propname = (char *)prom_nextprop(node, buf1, buf2)) { 150 if (strlen(propname) == 0) 151 break; /* end of prop list */ 152 153 (void) strcpy(buf1, propname); 154 155 proplen = prom_getproplen(node, propname); 156 if (proplen == 0) 157 continue; 158 propval = kmem_zalloc(proplen + 1, KM_SLEEP); 159 (void) prom_getprop(node, propname, propval); 160 161 if (strcmp(propval, path) == 0) { 162 kmem_free(propval, proplen + 1); 163 kmem_free(buf1, OBP_MAXPROPNAME); 164 sm_dbg('A', ("Alias is : %s\n", buf2)); 165 return (buf2); 166 } 167 168 kmem_free(propval, proplen + 1); 169 bzero(buf2, OBP_MAXPROPNAME); 170 } 171 172 kmem_free(buf1, OBP_MAXPROPNAME); 173 kmem_free(buf2, OBP_MAXPROPNAME); 174 175 return (NULL); 176 } 177 178 /* 179 * Tell OBP that this device is now usable 180 */ 181 static void 182 enable_device(sm_mux_state_t *ms, sm_console_t *cn) 183 { 184 char *enb_str = "\" enable-device\" rot $call-method"; 185 186 if (!cn->sm_obp_con) 187 return; 188 189 sm_dbg('A', ("ttymux: enabling %d:%d\n", 190 getmajor(cn->sm_dev), getminor(cn->sm_dev))); 191 192 if (cn->sm_i_ihdl != 0) 193 prom_interpret(enb_str, (caddr32_t)ms->sm_cons_stdin.sm_i_ihdl, 194 (caddr32_t)cn->sm_i_ihdl, 0, 0, 0); 195 196 if (cn->sm_o_ihdl != 0 && cn->sm_o_ihdl != cn->sm_i_ihdl) 197 prom_interpret(enb_str, (caddr32_t)ms->sm_cons_stdout.sm_o_ihdl, 198 (caddr32_t)cn->sm_o_ihdl, 0, 0, 0); 199 } 200 201 /* 202 * Tell OBP that this device is no longer usable 203 */ 204 static void 205 disable_device(sm_mux_state_t *ms, sm_console_t *cn) 206 { 207 char *dis_str = "\" disable-device\" rot $call-method"; 208 209 if (!cn->sm_obp_con) 210 return; 211 212 sm_dbg('A', ("ttymux: disabling %d:%d\n", 213 getmajor(cn->sm_dev), getminor(cn->sm_dev))); 214 215 if (cn->sm_i_ihdl != 0) 216 prom_interpret(dis_str, (caddr32_t)ms->sm_cons_stdin.sm_i_ihdl, 217 (caddr32_t)cn->sm_i_ihdl, 0, 0, 0); 218 if (cn->sm_o_ihdl != 0 && cn->sm_o_ihdl != cn->sm_i_ihdl) 219 prom_interpret(dis_str, (caddr32_t)ms->sm_cons_stdout.sm_o_ihdl, 220 (caddr32_t)cn->sm_o_ihdl, 0, 0, 0); 221 } 222 223 static void 224 device_init_impl(sm_mux_state_t *ms, sm_console_t *cn, sm_lqi_t *plqi) 225 { 226 uint_t flags = 0; 227 dev_info_t *ldip; 228 229 sm_dbg('I', ("device_init_impl:\n")); 230 231 if (plqi == NULL || cn == NULL) 232 return; 233 234 flags = (uint_t)cn->sm_mode; 235 sm_dbg('I', ("device_init_impl: flgs %d con %d\n", flags, 236 cn->sm_obp_con)); 237 if (ldip = e_ddi_hold_devi_by_dev(cn->sm_dev, 0)) { 238 239 /* 240 * Indicate to the linked device that it is 241 * providing a multiplexed console. 242 */ 243 if (flags & (uint_t)FORINPUT) 244 (void) e_ddi_prop_create(cn->sm_dev, ldip, 245 DDI_PROP_CANSLEEP, "obp-input-console", 0, 0); 246 if (flags & (uint_t)FOROUTPUT) 247 (void) e_ddi_prop_create(cn->sm_dev, ldip, 248 DDI_PROP_CANSLEEP, "obp-output-console", 0, 0); 249 250 ddi_release_devi(ldip); 251 } 252 253 if (flags) { 254 plqi->sm_ioflag = flags; 255 if (cn->sm_obp_con) 256 plqi->sm_uqflags |= SM_OBPCNDEV; 257 plqi->sm_ctrla_abort_on = sm_ssp->sm_ctrla_abort_on; 258 plqi->sm_break_abort_on = sm_ssp->sm_break_abort_on; 259 } 260 261 /* 262 * Tell OBP that its ok to use this console 263 */ 264 enable_device(ms, cn); 265 } 266 267 static void 268 device_fini_impl(sm_mux_state_t *ms, sm_console_t *cn, sm_lqi_t *plqi) 269 { 270 dev_info_t *ldip; 271 272 if (plqi == NULL || cn == NULL) 273 return; 274 /* 275 * Indicate to the linked device that it is no longer 276 * providing a multiplexed console. 277 */ 278 if (ldip = e_ddi_hold_devi_by_dev(plqi->sm_dev, 0)) { 279 if (plqi->sm_ioflag & (uint_t)FORINPUT) 280 (void) e_ddi_prop_remove(plqi->sm_dev, 281 ldip, "obp-input-console"); 282 if (plqi->sm_ioflag & (uint_t)FOROUTPUT) 283 (void) e_ddi_prop_remove(plqi->sm_dev, 284 ldip, "obp-output-console"); 285 286 ddi_release_devi(ldip); 287 } 288 plqi->sm_ioflag = 0; 289 plqi->sm_uqflags &= ~SM_OBPCNDEV; 290 disable_device(ms, cn); 291 } 292 293 static int 294 read_prop(dnode_t node, char *propname, char **propval) 295 { 296 int proplen = prom_getproplen(node, propname); 297 298 if (proplen < 0) 299 return (proplen); 300 *propval = kmem_zalloc(proplen + 1, KM_SLEEP); 301 if (proplen > 0) 302 (void) prom_getprop(node, propname, *propval); 303 else 304 *propval = 0; 305 306 return (proplen); 307 } 308 309 /* 310 * Parse a list of tokens 311 */ 312 static char * 313 sm_strtok_r(char *p, char *sep, char **lasts) 314 { 315 char *e, *tok = NULL; 316 317 if (p == 0 || *p == 0) 318 return (NULL); 319 320 e = p + strlen(p); 321 322 do { 323 if (strchr(sep, *p) != NULL) { 324 if (tok != NULL) { 325 *p = 0; 326 *lasts = p + 1; 327 return (tok); 328 } 329 } else if (tok == NULL) { 330 tok = p; 331 } 332 } while (++p < e); 333 334 *lasts = NULL; 335 if (tok != NULL) 336 return (tok); 337 return (NULL); 338 } 339 340 /* 341 * Add or remove an alias from a property list of aliases: 342 * path: an OBP device path 343 * pname: property name containing a space separated list of aliases 344 * append: if true include the alias for path in the property list 345 * otherwise remove the alias from the list. 346 */ 347 static int 348 upd_config(boolean_t append, char *pname, char *path) 349 { 350 dnode_t onode, anode; 351 size_t plen; /* length of property name */ 352 char *pval; /* value of property */ 353 char *tok, *lasts; 354 char *aliases[TTYMUX_MAX_LINKS]; 355 size_t i, cnt, len; 356 boolean_t found; 357 char *nval, *alias = NULL; 358 359 if ((anode = prom_alias_node()) == OBP_BADNODE || 360 (onode = prom_optionsnode()) == OBP_BADNODE) { 361 sm_dbg('I', ("upd_config: no alias or options node.\n")); 362 return (1); 363 } 364 365 if ((plen = read_prop(onode, pname, &pval)) < 0) 366 return (1); 367 368 sm_dbg('I', ("upd_config: %s=%s (%s)\n", pname, pval, path)); 369 found = B_FALSE; 370 for (len = 0, cnt = 0, tok = sm_strtok_r(pval, " \t", &lasts); 371 tok != NULL && cnt < TTYMUX_MAX_LINKS; 372 tok = sm_strtok_r(lasts, " \t", &lasts)) { 373 char *aval; 374 size_t alen; 375 376 if ((alen = read_prop(anode, tok, &aval)) < 0) 377 continue; 378 379 /* does this alias match the requested path */ 380 if (strcmp(aval, path) == 0 || 381 (strstr(path, aval) != NULL && 382 strchr(aval, ':') == NULL && strchr(path, ':') != NULL && 383 strcmp(strchr(path, ':'), ":a") == 0)) { 384 if (!found && append) { 385 kmem_free(aval, alen + 1); 386 goto out; 387 } 388 found = B_TRUE; 389 } else { 390 aliases[cnt++] = tok; 391 len += strlen(tok) + 1; 392 } 393 kmem_free(aval, alen + 1); 394 } 395 396 sm_dbg('I', ("%d aliases\n", cnt)); 397 if (append) { 398 if (cnt + 1 == TTYMUX_MAX_LINKS) 399 goto out; 400 401 if ((alias = val2alias(anode, path)) == NULL) { 402 char *mnode = strstr(path, ":a"); 403 404 if (mnode != 0) { 405 *mnode = '\0'; 406 alias = val2alias(anode, path); 407 *mnode = ':'; 408 } 409 } 410 if (alias == NULL) { 411 sm_dbg('I', ("No alias for %s\n", path)); 412 goto out; 413 } 414 aliases[cnt++] = alias; 415 len += strlen(alias) + 1; 416 } else if (!found) { 417 goto out; 418 } 419 420 sm_dbg('I', ("%d aliases (len %d)\n", cnt, len)); 421 if (len == 0) 422 goto out; 423 ASSERT(len > 1 && cnt > 0); 424 425 nval = kmem_zalloc(len, KM_SLEEP); 426 for (i = 0; ; ) { 427 ASSERT(strlen(nval) + strlen(aliases[i]) + 1 <= len); 428 sm_dbg('I', ("alias %s\n", aliases[i])); 429 (void) strcat(nval, aliases[i]); 430 if (++i == cnt) 431 break; 432 (void) strcat(nval, " "); 433 } 434 435 sm_dbg('I', ("setprop: %s=%s (%d)\n", pname, nval, len)); 436 437 (void) prom_setprop(onode, pname, nval, len); 438 439 kmem_free(nval, len); 440 441 if (alias != NULL) 442 kmem_free(alias, OBP_MAXPROPNAME); 443 out: 444 sm_dbg('I', ("upd_config: returning.\n")); 445 kmem_free(pval, plen + 1); 446 return (0); 447 } 448 449 /* 450 * 451 */ 452 static int 453 update_config(sm_mux_state_t *ms, char *path, io_mode_t mode, int cmd) 454 { 455 sm_dbg('I', ("update_config: path %s io %d\n", path ? path : "", mode)); 456 if (path == 0 || *path == 0) { 457 sm_dbg('I', ("update_config: EINVAL - no path\n")); 458 return (1); 459 } 460 if (prom_is_openprom() == 0) 461 return (0); 462 463 if ((mode & FORINPUT) && ms->sm_ialias != NULL) 464 (void) upd_config((cmd == TTYMUX_ASSOC), ms->sm_ialias, path); 465 if ((mode & FOROUTPUT) && ms->sm_oalias != NULL) 466 (void) upd_config((cmd == TTYMUX_ASSOC), ms->sm_oalias, path); 467 return (0); 468 } 469 470 /* 471 * Convert a dev_t to a device path 472 */ 473 static char * 474 sm_di_path(dev_t dev) 475 { 476 char *p, *path; 477 478 if (dev == NODEV) 479 return (NULL); 480 481 p = kmem_zalloc(MAXPATHLEN + 1, KM_SLEEP); 482 if (ddi_dev_pathname(dev, S_IFCHR, p) == DDI_SUCCESS) { 483 path = kmem_alloc(strlen(p) + 1, KM_SLEEP); 484 (void) strcpy(path, p); 485 } 486 kmem_free(p, MAXPATHLEN + 1); 487 488 return (path); 489 } 490 491 static int 492 console_cmd(int cmd, ttymux_assoc_t *assoc) 493 { 494 sm_mux_state_t *ms; 495 sm_console_t *cn; 496 uint_t j; 497 498 sm_dbg('I', ("console_cmd ENTER: %s\n", cmd == TTYMUX_DISASSOC ? 499 "TTYMUX_DISASSOC" : "TTYMUX_ASSOC")); 500 501 if (assoc->ttymux_ldev == NODEV && *assoc->ttymux_path != '/') { 502 sm_lqi_t *lqi = get_lqi_byid(assoc->ttymux_linkid); 503 if (lqi == 0 || lqi->sm_dev == NODEV) { 504 sm_dbg('I', ("console_cmd: no id link %d cmd %d\n", 505 assoc->ttymux_linkid, cmd)); 506 return (EINVAL); 507 } 508 assoc->ttymux_ldev = lqi->sm_dev; 509 } 510 511 sm_dbg('I', ("console_cmd: path %s\n", assoc->ttymux_path)); 512 513 if ((ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR)) == 0) { 514 sm_dbg('I', ("console_cmd: No muxstate\n")); 515 return (0); 516 } 517 518 mutex_enter(&ms->sm_cons_mutex); 519 520 for (cn = ms->sm_cons_links, j = 0; 521 j < ms->sm_cons_cnt; cn++, j++) { 522 if (assoc->ttymux_ldev != NODEV && assoc->ttymux_ldev == 523 cn->sm_dev) { 524 break; 525 } else if (cn->sm_path != NULL && 526 strncmp(cn->sm_path, assoc->ttymux_path, MAXPATHLEN) == 0) { 527 break; 528 } 529 } 530 531 assoc->ttymux_path[MAXPATHLEN - 1] = 0; 532 if (cmd == TTYMUX_DISASSOC) { 533 if (j == ms->sm_cons_cnt) { 534 mutex_exit(&ms->sm_cons_mutex); 535 return (0); 536 } 537 538 /* 539 * Disable the console in OBP and then delete this console 540 * this console - note that this also deletes OBP 541 * information - i.e. once it is disassociated it cannot 542 * be reused as an OBP console - roll on polled I/O! 543 */ 544 sm_dbg('I', ("console_cmd: cleaning up\n")); 545 device_fini_impl(ms, cn, get_lqi_bydevt(assoc->ttymux_ldev)); 546 547 if (cn->sm_path == NULL) { 548 if (assoc->ttymux_ldev != NODEV) 549 cn->sm_path = sm_di_path(assoc->ttymux_ldev); 550 else 551 (void) update_config(ms, assoc->ttymux_path, 552 assoc->ttymux_ioflag, cmd); 553 } 554 if (cn->sm_path) { 555 (void) update_config(ms, cn->sm_path, cn->sm_mode, cmd); 556 kmem_free(cn->sm_path, strlen(cn->sm_path) + 1); 557 cn->sm_path = NULL; 558 } 559 ms->sm_cons_cnt -= 1; 560 if (ms->sm_cons_cnt > 0) 561 *cn = ms->sm_cons_links[ms->sm_cons_cnt]; 562 563 sm_dbg('I', ("console_cmd: console %d removed (cnt %d)\n", 564 j, ms->sm_cons_cnt)); 565 566 } else if (cmd == TTYMUX_ASSOC) { 567 568 if (j == ms->sm_cons_cnt) { 569 570 if (j == TTYMUX_MAX_LINKS) { 571 mutex_exit(&ms->sm_cons_mutex); 572 return (ENOMEM); 573 } 574 575 ms->sm_cons_cnt += 1; 576 577 bzero((caddr_t)cn, sizeof (*cn)); 578 cn->sm_dev = assoc->ttymux_ldev; 579 cn->sm_muxid = assoc->ttymux_linkid; 580 cn->sm_mode = assoc->ttymux_ioflag; 581 device_init_impl(ms, cn, 582 get_lqi_bydevt(assoc->ttymux_ldev)); 583 } else { 584 cn->sm_dev = assoc->ttymux_ldev; 585 cn->sm_muxid = assoc->ttymux_linkid; 586 cn->sm_mode = assoc->ttymux_ioflag; 587 } 588 589 if (assoc->ttymux_ldev != NODEV) { 590 cn->sm_path = sm_di_path(assoc->ttymux_ldev); 591 } else { 592 cn->sm_path = kmem_alloc(strlen(assoc->ttymux_path) + 1, 593 KM_SLEEP); 594 (void) strcpy(cn->sm_path, assoc->ttymux_path); 595 } 596 if (cn->sm_path != NULL) 597 (void) update_config(ms, cn->sm_path, cn->sm_mode, cmd); 598 else 599 sm_dbg('I', ("console_cmd: ASSOC No path info")); 600 } 601 mutex_exit(&ms->sm_cons_mutex); 602 sm_dbg('I', ("console_cmd EXIT: %s\n", cmd == TTYMUX_DISASSOC ? 603 "TTYMUX_DISASSOC" : "TTYMUX_ASSOC")); 604 return (0); 605 } 606 607 static int 608 get_unconfigured_consoles(sm_mux_state_t *ms, ttymux_assoc_t *a) 609 { 610 sm_console_t *cn; 611 int j, cnt; 612 613 if (ms == 0) 614 return (0); 615 616 mutex_enter(&ms->sm_cons_mutex); 617 for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt; 618 cn++, j++) { 619 if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL) { 620 a->ttymux_linkid = cn->sm_muxid; 621 a->ttymux_tag = (uint_t)0; 622 a->ttymux_ioflag = cn->sm_mode; 623 a->ttymux_udev = cn->sm_mode & FORINPUT ? 624 ms->sm_cons_stdin.sm_dev : 625 ms->sm_cons_stdout.sm_dev; 626 a->ttymux_ldev = NODEV; 627 (void) strncpy(a->ttymux_path, cn->sm_path, MAXPATHLEN); 628 cnt++; 629 a++; 630 } 631 } 632 mutex_exit(&ms->sm_cons_mutex); 633 return (cnt); 634 } 635 636 #ifdef _SYSCALL32_IMPL 637 /* 638 * Look for any consoles that are not currently plumbed under the multiplexer. 639 */ 640 static int 641 get_unconfigured_consoles32(sm_mux_state_t *ms, ttymux_assoc32_t *a) 642 { 643 sm_console_t *cn; 644 int j, cnt; 645 646 if (ms == 0) 647 return (0); 648 649 mutex_enter(&ms->sm_cons_mutex); 650 for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt; 651 cn++, j++) { 652 sm_dbg('I', ("get_unconfigured_consoles: check %s (%d:%d)", 653 cn->sm_path ? cn->sm_path : "NULL", 654 getmajor(cn->sm_dev), getminor(cn->sm_dev))); 655 if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL) { 656 a->ttymux32_linkid = 0; 657 a->ttymux32_tag = (uint32_t)0; 658 a->ttymux32_ioflag = (uint32_t)cn->sm_mode; 659 a->ttymux32_ldev = NODEV32; 660 (void) cmpldev(&a->ttymux32_udev, cn->sm_mode & 661 FORINPUT ? ms->sm_cons_stdin.sm_dev : 662 ms->sm_cons_stdout.sm_dev); 663 664 (void) strncpy(a->ttymux32_path, cn->sm_path, 665 MAXPATHLEN); 666 cnt++; 667 a++; 668 } 669 } 670 mutex_exit(&ms->sm_cons_mutex); 671 return (cnt); 672 } 673 #endif 674 675 static int 676 count_unconfigured_consoles(sm_mux_state_t *ms) 677 { 678 sm_console_t *cn; 679 int j, cnt; 680 681 if (ms == 0) 682 return (0); 683 684 mutex_enter(&ms->sm_cons_mutex); 685 for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt; 686 cn++, j++) { 687 sm_dbg('I', ("cnt_unconfigured_consoles: check %s (%d:%d)", 688 cn->sm_path ? cn->sm_path : "NULL", 689 getmajor(cn->sm_dev), getminor(cn->sm_dev))); 690 if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL) 691 cnt++; 692 } 693 mutex_exit(&ms->sm_cons_mutex); 694 return (cnt); 695 } 696 697 /* 698 * Exported interfaces 699 */ 700 701 /* 702 * A console device is no longer associated. 703 */ 704 int 705 ttymux_device_fini(sm_lqi_t *plqi) 706 { 707 int j; 708 sm_mux_state_t *ms; 709 710 ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR); 711 712 if (plqi == NULL || ms == NULL) 713 return (0); 714 715 mutex_enter(&ms->sm_cons_mutex); 716 717 for (j = 0; j < ms->sm_cons_cnt; j++) { 718 719 if (ms->sm_cons_links[j].sm_dev == plqi->sm_dev) { 720 721 device_fini_impl(ms, &ms->sm_cons_links[j], plqi); 722 723 mutex_exit(&ms->sm_cons_mutex); 724 return (0); 725 } 726 } 727 mutex_exit(&ms->sm_cons_mutex); 728 729 return (1); 730 } 731 732 /* 733 * A console device is being introduced. 734 */ 735 int 736 ttymux_device_init(sm_lqi_t *plqi) 737 { 738 int j; 739 sm_mux_state_t *ms; 740 741 ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR); 742 743 if (ms == NULL) 744 return (0); 745 746 mutex_enter(&ms->sm_cons_mutex); 747 748 for (j = 0; j < ms->sm_cons_cnt; j++) { 749 750 if (ms->sm_cons_links[j].sm_dev == plqi->sm_dev) { 751 752 device_init_impl(ms, &ms->sm_cons_links[j], plqi); 753 754 mutex_exit(&ms->sm_cons_mutex); 755 return (0); 756 } 757 } 758 mutex_exit(&ms->sm_cons_mutex); 759 return (1); 760 } 761 762 /* 763 * Process a TTYMUX_ASSOCIATE or TTYMUX_DISASSOCIATE ioctl. 764 */ 765 static int 766 ttymux_link_ioctl(mblk_t *mp) 767 { 768 ttymux_assoc_t assoc; 769 int err; 770 sm_lqi_t *lqi; 771 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 772 dev_t cidev, codev; 773 774 sm_dbg('I', ("ttymux_link_ioctl:\n")); 775 if ((err = mblk2assoc(mp, &assoc)) != 0) 776 return (err); 777 778 sm_dbg('I', ("uminor is %d\n", getminor(assoc.ttymux_udev))); 779 780 if (assoc.ttymux_udev == NODEV) 781 return (EINVAL); 782 783 err = 0; 784 785 if ((lqi = get_lqi_bydevt(assoc.ttymux_ldev)) == NULL) { 786 if (assoc.ttymux_linkid < 0) 787 err = EINVAL; 788 else if ((lqi = get_lqi_byid(assoc.ttymux_linkid)) == 0) 789 err = ENOLINK; 790 } 791 792 if (sm_ssp->sm_ms) { 793 mutex_enter(&sm_ssp->sm_ms->sm_cons_mutex); 794 cidev = sm_ssp->sm_ms->sm_cons_stdin.sm_dev; 795 codev = sm_ssp->sm_ms->sm_cons_stdout.sm_dev; 796 mutex_exit(&sm_ssp->sm_ms->sm_cons_mutex); 797 } else { 798 cidev = codev = NODEV; 799 } 800 801 if (err != 0) { 802 if (assoc.ttymux_udev != cidev && assoc.ttymux_udev != codev) 803 return (err); 804 (void) console_cmd(iobp->ioc_cmd, &assoc); 805 return (0); 806 } else if (assoc.ttymux_udev == cidev || assoc.ttymux_udev == codev) { 807 (void) console_cmd(iobp->ioc_cmd, &assoc); 808 } 809 810 if (iobp->ioc_cmd == TTYMUX_ASSOC) 811 return (sm_associate(sm_dev2unit(assoc.ttymux_udev), 812 lqi, assoc.ttymux_tag, assoc.ttymux_ioflag, 813 assoc.ttymux_path)); 814 else if (iobp->ioc_cmd == TTYMUX_DISASSOC) 815 return (sm_disassociate(sm_dev2unit(assoc.ttymux_udev), 816 lqi, assoc.ttymux_tag)); 817 818 return (0); 819 } 820 821 /* 822 * Process a TTYMUX_GETLINK ioctl. 823 */ 824 int 825 ttymux_query_link_ioctl(mblk_t *mp) 826 { 827 sm_lqi_t *lqi; 828 829 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 830 831 sm_dbg('I', ("ttymux_query_link_ioctl:\n")); 832 833 if (mp->b_cont == NULL) 834 return (EINVAL); 835 836 #ifdef _SYSCALL32_IMPL 837 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 838 ttymux_assoc32_t *assoc32; 839 ttymux_assoc_t assoc; 840 841 if (mblk2assoc(mp, &assoc) != 0) 842 return (EINVAL); 843 844 if ((lqi = get_lqi_bydevt(assoc.ttymux_ldev)) == NULL && 845 (lqi = get_lqi_byid(assoc.ttymux_linkid)) == NULL) { 846 sm_dbg('M', ("Query Link (%d): dev %d:%d not found\n", 847 assoc.ttymux_linkid, 848 getmajor(assoc.ttymux_ldev), 849 getminor(assoc.ttymux_ldev))); 850 return (ENOLINK); 851 } 852 assoc32 = (ttymux_assoc32_t *)mp->b_cont->b_rptr; 853 LQI2ASSOC32(assoc32, lqi); 854 } else 855 #endif 856 { 857 ttymux_assoc_t *assoc; 858 859 if (iobp->ioc_count < sizeof (ttymux_assoc_t)) 860 return (EINVAL); 861 862 assoc = (ttymux_assoc_t *)mp->b_cont->b_rptr; 863 if ((lqi = get_lqi_bydevt(assoc->ttymux_ldev)) == NULL && 864 (lqi = get_lqi_byid(assoc->ttymux_linkid)) == NULL) { 865 return (ENOLINK); 866 } 867 LQI2ASSOC(assoc, lqi); 868 } 869 return (0); 870 } 871 872 /* 873 * Response to receiving an M_IOCDATA message for the TTYMUX_LIST ioctl. 874 */ 875 static int 876 sm_iocresp(mblk_t *mp) 877 { 878 struct copyresp *csp = (struct copyresp *)mp->b_rptr; 879 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 880 mblk_t *pmp; 881 882 sm_dbg('M', ("(M_IOCDATA: cmd %d)\n", csp->cp_cmd)); 883 884 if (csp->cp_cmd != TTYMUX_LIST) { 885 sm_dbg('M', ("(M_IOCDATA: unknown cmd)\n")); 886 DB_TYPE(mp) = M_IOCNAK; 887 return (EINVAL); 888 } 889 if (csp->cp_rval) { 890 if (csp->cp_private) 891 freemsg((mblk_t *)csp->cp_private); 892 893 sm_dbg('M', ("M_IOCDATA: result is %d\n", csp->cp_rval)); 894 DB_TYPE(mp) = M_IOCNAK; 895 iobp->ioc_error = (int)(uintptr_t)csp->cp_rval; 896 iobp->ioc_rval = 0; 897 return (iobp->ioc_error); 898 } 899 900 pmp = (mblk_t *)csp->cp_private; 901 902 #ifdef _SYSCALL32_IMPL 903 if ((csp->cp_flag & IOC_MODELS) != IOC_NATIVE) { 904 iobp->ioc_count = sizeof (ttymux_assocs32_t); 905 iobp->ioc_rval = pmp == NULL ? 0 : 906 ((ttymux_assocs32_t *)pmp->b_rptr)->ttymux32_nlinks; 907 } else 908 #endif 909 { 910 iobp->ioc_count = sizeof (ttymux_assocs_t); 911 iobp->ioc_rval = pmp == NULL ? 0 : 912 ((ttymux_assocs_t *)pmp->b_rptr)->ttymux_nlinks; 913 914 } 915 916 DB_TYPE(mp) = (pmp) ? M_IOCACK : M_IOCNAK; 917 mp->b_wptr = mp->b_rptr + sizeof (struct iocblk); 918 919 if (mp->b_cont) 920 freemsg(unlinkb(mp)); 921 if (pmp) 922 linkb(mp, pmp); 923 else 924 iobp->ioc_count = 0; 925 926 iobp->ioc_error = 0; 927 928 sm_dbg('M', ("(M_IOCDATA: rval %d cnt %d private 0x%p)\n", 929 iobp->ioc_rval, iobp->ioc_count, pmp)); 930 return (0); 931 } 932 933 /* 934 * Process a TTYMUX_LIST ioctl. 935 */ 936 int 937 ttymux_query_links_ioctl(mblk_t *mp) 938 { 939 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 940 struct copyreq *cqp; 941 int unit; 942 sm_lqi_t *lqi; 943 mblk_t *nmp; 944 int cnt; 945 void *asl; 946 void *uaddr; 947 size_t sz; 948 949 if (DB_TYPE(mp) == M_IOCDATA) { 950 return (sm_iocresp(mp)); 951 } 952 /* 953 * Is this a query for the number of linked devices? 954 */ 955 if (iobp->ioc_count == 0) { 956 957 for (unit = 0, iobp->ioc_rval = 0; 958 unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit)); 959 unit++) 960 if (lqi->sm_linkid != 0) 961 iobp->ioc_rval += 1; 962 963 iobp->ioc_rval += count_unconfigured_consoles(sm_ssp->sm_ms); 964 DB_TYPE(mp) = M_IOCACK; 965 iobp->ioc_error = 0; 966 967 return (0); 968 } 969 970 if (mp->b_cont == NULL) { 971 sm_dbg('Y', ("TTYMUX_LIST: b_cont is NULL\n")); 972 DB_TYPE(mp) = M_IOCNAK; 973 iobp->ioc_error = EINVAL; 974 return (EINVAL); 975 } 976 977 asl = mp->b_cont->b_rptr; 978 979 #ifdef _SYSCALL32_IMPL 980 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 981 cnt = ((ttymux_assocs32_t *)asl)->ttymux32_nlinks; 982 sz = cnt * sizeof (ttymux_assoc32_t); 983 uaddr = (void *)(uintptr_t) 984 ((ttymux_assocs32_t *)asl)->ttymux32_assocs; 985 } else 986 #endif 987 { 988 cnt = ((ttymux_assocs_t *)asl)->ttymux_nlinks; 989 sz = cnt * sizeof (ttymux_assoc_t); 990 uaddr = (void *)((ttymux_assocs_t *)asl)->ttymux_assocs; 991 } 992 if ((nmp = sm_allocb(sz, BPRI_MED)) == NULL) { 993 DB_TYPE(mp) = M_IOCNAK; 994 iobp->ioc_error = EINVAL; 995 return (EAGAIN); 996 } 997 998 sm_dbg('Y', ("TTYMUX_LIST: cnt %d sz %d uaddr 0x%p\n", cnt, sz, uaddr)); 999 1000 iobp->ioc_rval = 0; 1001 1002 #ifdef _SYSCALL32_IMPL 1003 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 1004 ttymux_assoc32_t *assoc; 1005 1006 sm_dbg('Y', ("!Native: %d structures\n", cnt)); 1007 assoc = (ttymux_assoc32_t *)nmp->b_rptr; 1008 1009 for (unit = 0; 1010 unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit)); 1011 unit++) { 1012 if (lqi->sm_linkid != 0) { 1013 if (cnt-- == 0) 1014 break; 1015 LQI2ASSOC32(assoc, lqi); 1016 assoc++; 1017 iobp->ioc_rval += 1; 1018 } 1019 } 1020 if (cnt > 0) { 1021 /* see if there are unconfigured consoles */ 1022 iobp->ioc_rval += 1023 get_unconfigured_consoles32(sm_ssp->sm_ms, assoc); 1024 sm_dbg('I', ("%d unconfigured consoles\n", 1025 iobp->ioc_rval)); 1026 } else { 1027 sm_dbg('I', ("no more space in user addr\n")); 1028 } 1029 ((ttymux_assocs32_t *)asl)->ttymux32_nlinks = iobp->ioc_rval; 1030 } else 1031 #endif 1032 { 1033 ttymux_assoc_t *assoc; 1034 1035 sm_dbg('Y', ("!Native: %d structures\n", cnt)); 1036 assoc = (ttymux_assoc_t *)nmp->b_wptr; 1037 1038 for (unit = 0; 1039 unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit)); 1040 unit++) { 1041 if (lqi->sm_linkid != 0) { 1042 if (cnt-- == 0) 1043 break; 1044 LQI2ASSOC(assoc, lqi); 1045 assoc++; 1046 iobp->ioc_rval += 1; 1047 } 1048 } 1049 if (cnt > 0) { 1050 /* see if there are unconfigured consoles */ 1051 iobp->ioc_rval += 1052 get_unconfigured_consoles(sm_ssp->sm_ms, assoc); 1053 sm_dbg('I', ("%d unconfigured consoles\n", 1054 iobp->ioc_rval)); 1055 } else { 1056 sm_dbg('I', ("no more space in user addr\n")); 1057 } 1058 ((ttymux_assocs_t *)asl)->ttymux_nlinks = iobp->ioc_rval; 1059 } 1060 1061 cqp = (struct copyreq *)mp->b_rptr; 1062 cqp->cq_addr = uaddr; 1063 cqp->cq_size = sz; 1064 cqp->cq_flag = 0; 1065 cqp->cq_private = mp->b_cont; 1066 mp->b_cont = nmp; 1067 nmp->b_wptr = nmp->b_rptr + sz; 1068 1069 DB_TYPE(mp) = M_COPYOUT; 1070 mp->b_wptr = mp->b_rptr + sizeof (struct copyreq); 1071 1072 return (0); 1073 } 1074 1075 /* 1076 * Process a TTYMUX_CONSDEV ioctl. 1077 */ 1078 static int 1079 ttymux_console_ioctl(mblk_t *mp) 1080 { 1081 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 1082 int err = EINVAL; 1083 1084 sm_dbg('I', ("ttymux_console_ioctl:\n")); 1085 #ifdef _SYSCALL32_IMPL 1086 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 1087 if (mp->b_cont && iobp->ioc_count >= sizeof (dev32_t)) { 1088 dev32_t dev; 1089 1090 (void) cmpldev(&dev, rconsdev); 1091 1092 *(dev32_t *)mp->b_cont->b_rptr = dev; 1093 mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof (dev); 1094 iobp->ioc_count = sizeof (dev); 1095 err = 0; 1096 } else { 1097 sm_dbg('I', ("TTYMUX_CONSDEV: b_cont 0x%p count %d\n", 1098 mp->b_cont, iobp->ioc_count)); 1099 } 1100 } else 1101 #endif 1102 if (mp->b_cont && iobp->ioc_count >= sizeof (dev_t)) { 1103 *(dev_t *)mp->b_cont->b_rptr = rconsdev; 1104 mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof (rconsdev); 1105 iobp->ioc_count = sizeof (rconsdev); 1106 err = 0; 1107 } 1108 return (err); 1109 } 1110 1111 /* 1112 * Process a ioctl relating to aborting on the console. 1113 */ 1114 int 1115 ttymux_abort_ioctl(mblk_t *mp) 1116 { 1117 struct iocblk *iobp; 1118 int cmd, err = 0; 1119 sm_lqi_t *lqi; 1120 ttymux_abort_t *abreq; 1121 #ifdef _SYSCALL32_IMPL 1122 struct ttymux_abort32 { 1123 dev32_t ldev; 1124 enum ttymux_break_type method; 1125 uint32_t enable; 1126 } *abreq32; 1127 #endif 1128 dev_t ldev; 1129 enum ttymux_break_type method; 1130 uint_t enable; 1131 1132 iobp = (struct iocblk *)mp->b_rptr; 1133 cmd = iobp->ioc_cmd; 1134 1135 iobp->ioc_error = 0; 1136 iobp->ioc_rval = 0; 1137 sm_dbg('I', ("ttymux_abort_ioctl:\n")); 1138 switch (cmd) { 1139 case CONSSETABORTENABLE: 1140 lqi = (sm_ssp->sm_lconsole) ? sm_ssp->sm_lconsole->sm_lqs : 0; 1141 enable = (*(intptr_t *)mp->b_cont->b_rptr) ? 1 : 0; 1142 sm_ssp->sm_ctrla_abort_on = sm_ssp->sm_break_abort_on = enable; 1143 for (; lqi != 0; lqi = lqi->sm_nlqi) { 1144 lqi->sm_ctrla_abort_on = enable; 1145 lqi->sm_break_abort_on = enable; 1146 } 1147 break; 1148 case CONSGETABORTENABLE: 1149 if (mp->b_cont == 0 || iobp->ioc_count < sizeof (intptr_t)) { 1150 iobp->ioc_error = EINVAL; 1151 iobp->ioc_rval = -1; 1152 } else { 1153 *(intptr_t *)mp->b_cont->b_rptr = 1154 (sm_ssp->sm_ctrla_abort_on || 1155 sm_ssp->sm_break_abort_on); 1156 mp->b_cont->b_wptr = 1157 mp->b_cont->b_rptr + sizeof (intptr_t); 1158 iobp->ioc_count = sizeof (intptr_t); 1159 } 1160 break; 1161 case TTYMUX_GETABORTSTR: 1162 1163 if (iobp->ioc_count < strlen(sm_ssp->sm_abs) + 1 || 1164 mp->b_cont == 0 || 1165 mp->b_cont->b_cont) { 1166 iobp->ioc_error = EINVAL; 1167 iobp->ioc_rval = -1; 1168 } else { 1169 (void) strcpy((char *)mp->b_cont->b_rptr, 1170 sm_ssp->sm_abs); 1171 iobp->ioc_count = strlen(sm_ssp->sm_abs) + 1; 1172 mp->b_cont->b_wptr = 1173 mp->b_cont->b_rptr + iobp->ioc_count; 1174 } 1175 break; 1176 case TTYMUX_GETABORT: 1177 case TTYMUX_SETABORT: 1178 1179 lqi = 0; 1180 #ifdef _SYSCALL32_IMPL 1181 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 1182 if (iobp->ioc_count < sizeof (*abreq32) || 1183 mp->b_cont == 0) { 1184 err = EINVAL; 1185 } else { 1186 abreq32 = (struct ttymux_abort32 *) 1187 mp->b_cont->b_rptr; 1188 ldev = expldev(abreq32->ldev); 1189 method = abreq32->method; 1190 enable = (uint_t)abreq32->enable; 1191 iobp->ioc_count = sizeof (*abreq32); 1192 } 1193 } else 1194 #endif 1195 if (iobp->ioc_count < sizeof (*abreq) || 1196 mp->b_cont == 0) { 1197 err = EINVAL; 1198 } else { 1199 abreq = (ttymux_abort_t *)mp->b_cont->b_rptr; 1200 ldev = abreq->ttymux_ldev; 1201 method = abreq->ttymux_method; 1202 enable = abreq->ttymux_enable; 1203 iobp->ioc_count = sizeof (*abreq); 1204 } 1205 1206 if (err != 0) { 1207 iobp->ioc_rval = -1; 1208 return ((iobp->ioc_error = err)); 1209 } 1210 1211 sm_dbg('Y', ("ttymux_abort_ioctl: type %d how %d ldev %d:%d\n", 1212 method, enable, getmajor(ldev), getminor(ldev))); 1213 1214 lqi = get_lqi_bydevt(ldev); 1215 if (ldev != NODEV && lqi == 0) { 1216 err = ENOLINK; 1217 } else if (cmd == TTYMUX_GETABORT && lqi == 0) { 1218 err = ENODEV; 1219 } else if (cmd == TTYMUX_GETABORT) { 1220 if (lqi->sm_break_abort_on == 0 && 1221 lqi->sm_ctrla_abort_on == 0) { 1222 method = SOFTHARD_BREAK; 1223 enable = 0; 1224 } else { 1225 enable = 1; 1226 if (lqi->sm_break_abort_on == 0) 1227 method = SOFTWARE_BREAK; 1228 else if (lqi->sm_ctrla_abort_on == 0) 1229 method = HARDWARE_BREAK; 1230 else 1231 method = SOFTHARD_BREAK; 1232 } 1233 1234 #ifdef _SYSCALL32_IMPL 1235 if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 1236 abreq32->method = method; 1237 abreq32->enable = (uint32_t)enable; 1238 } else 1239 #endif 1240 { 1241 abreq->ttymux_method = method; 1242 abreq->ttymux_enable = enable; 1243 } 1244 } else { 1245 iobp->ioc_count = 0; 1246 sm_dbg('I', ("lqi is 0x%p\n", lqi)); 1247 if (lqi == 0) { 1248 if (method == HARDWARE_BREAK) 1249 sm_ssp->sm_break_abort_on = enable; 1250 else if (method == SOFTWARE_BREAK) 1251 sm_ssp->sm_ctrla_abort_on = enable; 1252 else if (method == SOFTHARD_BREAK) { 1253 sm_ssp->sm_break_abort_on = enable; 1254 sm_ssp->sm_ctrla_abort_on = enable; 1255 } else { 1256 sm_dbg('I', ("%d - invalid\n", method)); 1257 iobp->ioc_rval = -1; 1258 return ((iobp->ioc_error = EINVAL)); 1259 } 1260 1261 if (sm_ssp->sm_lconsole) { 1262 sm_dbg('I', ("lconsole 0x%p (0x%p)\n", 1263 sm_ssp->sm_lconsole, 1264 sm_ssp->sm_lconsole->sm_lqs)); 1265 } else { 1266 sm_dbg('I', ("lconsole is null\n")); 1267 } 1268 1269 lqi = (sm_ssp->sm_lconsole) ? 1270 sm_ssp->sm_lconsole->sm_lqs : 0; 1271 } 1272 while (lqi) { 1273 if (method == HARDWARE_BREAK) 1274 lqi->sm_break_abort_on = enable; 1275 else if (method == SOFTWARE_BREAK) 1276 lqi->sm_ctrla_abort_on = enable; 1277 else if (method == SOFTHARD_BREAK) { 1278 lqi->sm_break_abort_on = enable; 1279 lqi->sm_ctrla_abort_on = enable; 1280 } else { 1281 sm_dbg('I', ("%d: invalid\n", method)); 1282 iobp->ioc_rval = -1; 1283 return ((iobp->ioc_error = EINVAL)); 1284 } 1285 1286 lqi = (ldev == NODEV) ? lqi->sm_nlqi : 0; 1287 } 1288 } 1289 iobp->ioc_rval = err ? -1 : 0; 1290 iobp->ioc_error = err; 1291 break; 1292 default: 1293 iobp->ioc_rval = -1; 1294 iobp->ioc_error = EINVAL; 1295 } 1296 return (iobp->ioc_error); 1297 } 1298 1299 /* 1300 * Process ioctls specific to the ttymux driver. 1301 */ 1302 /*ARGSUSED*/ 1303 int 1304 sm_ioctl_cmd(sm_uqi_t *uqi, mblk_t *mp) 1305 { 1306 struct iocblk *iobp = (struct iocblk *)mp->b_rptr; 1307 1308 iobp->ioc_rval = 0; 1309 1310 /* 1311 * This routine does not support transparent ioctls 1312 */ 1313 if (iobp->ioc_count == TRANSPARENT) { 1314 sm_dbg('Y', ("sm_ioctl_cmd: unsupported ioctl\n")); 1315 iobp->ioc_error = ENOTSUP; 1316 DB_TYPE(mp) = M_IOCNAK; 1317 if (mp->b_cont) 1318 freemsg(unlinkb(mp)); 1319 return (ENOTSUP); 1320 } 1321 1322 switch (iobp->ioc_cmd) { 1323 case TTYMUX_CONSDEV: 1324 iobp->ioc_error = ttymux_console_ioctl(mp); 1325 break; 1326 case TTYMUX_ASSOC: 1327 case TTYMUX_DISASSOC: 1328 iobp->ioc_error = ttymux_link_ioctl(mp); 1329 break; 1330 case TTYMUX_GETLINK: 1331 iobp->ioc_error = ttymux_query_link_ioctl(mp); 1332 break; 1333 case TTYMUX_LIST: 1334 return (ttymux_query_links_ioctl(mp)); 1335 case TTYMUX_SETCTL: 1336 case TTYMUX_GETCTL: 1337 iobp->ioc_error = ENOTSUP; 1338 break; 1339 case TTYMUX_GETABORTSTR: 1340 case TTYMUX_SETABORT: 1341 case TTYMUX_GETABORT: 1342 iobp->ioc_error = ttymux_abort_ioctl(mp); 1343 break; 1344 default: 1345 iobp->ioc_error = EINVAL; 1346 break; 1347 } 1348 1349 DB_TYPE(mp) = iobp->ioc_error ? M_IOCNAK : M_IOCACK; 1350 1351 if ((iobp->ioc_error || iobp->ioc_count == 0) && mp->b_cont) 1352 freemsg(unlinkb(mp)); 1353 1354 sm_dbg('I', ("TTYMUX IOCTL: err %d rval %d count %d\n", 1355 iobp->ioc_error, iobp->ioc_rval, iobp->ioc_count)); 1356 1357 return (iobp->ioc_error); 1358 } 1359