bsd_init.c (20852B)
1 /* 2 * Copyright 1992 by Rich Murphey <Rich@Rice.edu> 3 * Copyright 1993 by David Wexelblat <dwex@goblin.org> 4 * 5 * Permission to use, copy, modify, distribute, and sell this software and its 6 * documentation for any purpose is hereby granted without fee, provided that 7 * the above copyright notice appear in all copies and that both that 8 * copyright notice and this permission notice appear in supporting 9 * documentation, and that the names of Rich Murphey and David Wexelblat 10 * not be used in advertising or publicity pertaining to distribution of 11 * the software without specific, written prior permission. Rich Murphey and 12 * David Wexelblat make no representations about the suitability of this 13 * software for any purpose. It is provided "as is" without express or 14 * implied warranty. 15 * 16 * RICH MURPHEY AND DAVID WEXELBLAT DISCLAIM ALL WARRANTIES WITH REGARD TO 17 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 18 * FITNESS, IN NO EVENT SHALL RICH MURPHEY OR DAVID WEXELBLAT BE LIABLE FOR 19 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 20 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 21 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 22 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 23 * 24 */ 25 26 #ifdef HAVE_XORG_CONFIG_H 27 #include <xorg-config.h> 28 #endif 29 30 #include <X11/X.h> 31 32 #include "compiler.h" 33 34 #include "xf86.h" 35 #include "xf86Priv.h" 36 #include "xf86_OSlib.h" 37 38 #include <sys/utsname.h> 39 #include <sys/ioctl.h> 40 #include <stdlib.h> 41 #include <errno.h> 42 43 static Bool KeepTty = FALSE; 44 45 #ifdef PCCONS_SUPPORT 46 static int devConsoleFd = -1; 47 #endif 48 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 49 static int VTnum = -1; 50 static int initialVT = -1; 51 #endif 52 53 #ifdef PCCONS_SUPPORT 54 /* Stock 0.1 386bsd pccons console driver interface */ 55 #define PCCONS_CONSOLE_DEV1 "/dev/ttyv0" 56 #define PCCONS_CONSOLE_DEV2 "/dev/vga" 57 #define PCCONS_CONSOLE_MODE O_RDWR|O_NDELAY 58 #endif 59 60 #ifdef SYSCONS_SUPPORT 61 /* The FreeBSD 1.1 version syscons driver uses /dev/ttyv0 */ 62 #define SYSCONS_CONSOLE_DEV1 "/dev/ttyv0" 63 #define SYSCONS_CONSOLE_DEV2 "/dev/vga" 64 #define SYSCONS_CONSOLE_MODE O_RDWR|O_NDELAY 65 #endif 66 67 #ifdef PCVT_SUPPORT 68 /* Hellmuth Michaelis' pcvt driver */ 69 #ifndef __OpenBSD__ 70 #define PCVT_CONSOLE_DEV "/dev/ttyv0" 71 #else 72 #define PCVT_CONSOLE_DEV "/dev/ttyC0" 73 #endif 74 #define PCVT_CONSOLE_MODE O_RDWR|O_NDELAY 75 #endif 76 77 #if defined(WSCONS_SUPPORT) && defined(__NetBSD__) 78 /* NetBSD's new console driver */ 79 #define WSCONS_PCVT_COMPAT_CONSOLE_DEV "/dev/ttyE0" 80 #endif 81 82 #ifdef __GLIBC__ 83 #define setpgrp setpgid 84 #endif 85 86 #define CHECK_DRIVER_MSG \ 87 "Check your kernel's console driver configuration and /dev entries" 88 89 static char *supported_drivers[] = { 90 #ifdef PCCONS_SUPPORT 91 "pccons (with X support)", 92 #endif 93 #ifdef SYSCONS_SUPPORT 94 "syscons", 95 #endif 96 #ifdef PCVT_SUPPORT 97 "pcvt", 98 #endif 99 #ifdef WSCONS_SUPPORT 100 "wscons", 101 #endif 102 }; 103 104 /* 105 * Functions to probe for the existence of a supported console driver. 106 * Any function returns either a valid file descriptor (driver probed 107 * successfully), -1 (driver not found), or uses FatalError() if the 108 * driver was found but proved to not support the required mode to run 109 * an X server. 110 */ 111 112 typedef int (*xf86ConsOpen_t) (void); 113 114 #ifdef PCCONS_SUPPORT 115 static int xf86OpenPccons(void); 116 #endif /* PCCONS_SUPPORT */ 117 118 #ifdef SYSCONS_SUPPORT 119 static int xf86OpenSyscons(void); 120 #endif /* SYSCONS_SUPPORT */ 121 122 #ifdef PCVT_SUPPORT 123 static int xf86OpenPcvt(void); 124 #endif /* PCVT_SUPPORT */ 125 126 #ifdef WSCONS_SUPPORT 127 static int xf86OpenWScons(void); 128 #endif 129 130 /* 131 * The sequence of the driver probes is important; start with the 132 * driver that is best distinguishable, and end with the most generic 133 * driver. (Otherwise, pcvt would also probe as syscons, and either 134 * pcvt or syscons might successfully probe as pccons.) 135 */ 136 static xf86ConsOpen_t xf86ConsTab[] = { 137 #ifdef PCVT_SUPPORT 138 xf86OpenPcvt, 139 #endif 140 #ifdef SYSCONS_SUPPORT 141 xf86OpenSyscons, 142 #endif 143 #ifdef PCCONS_SUPPORT 144 xf86OpenPccons, 145 #endif 146 #ifdef WSCONS_SUPPORT 147 xf86OpenWScons, 148 #endif 149 (xf86ConsOpen_t) NULL 150 }; 151 152 void 153 xf86OpenConsole() 154 { 155 int i, fd = -1; 156 xf86ConsOpen_t *driver; 157 158 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 159 int result; 160 161 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 162 struct utsname uts; 163 #endif 164 vtmode_t vtmode; 165 #endif 166 167 if (serverGeneration == 1) { 168 /* check if we are run with euid==0 */ 169 if (geteuid() != 0) { 170 FatalError("xf86OpenConsole: Server must be suid root"); 171 } 172 173 if (!KeepTty) { 174 /* 175 * detaching the controlling tty solves problems of kbd character 176 * loss. This is not interesting for CO driver, because it is 177 * exclusive. 178 */ 179 setpgrp(0, getpid()); 180 if ((i = open("/dev/tty", O_RDWR)) >= 0) { 181 ioctl(i, TIOCNOTTY, (char *) 0); 182 close(i); 183 } 184 } 185 186 /* detect which driver we are running on */ 187 for (driver = xf86ConsTab; *driver; driver++) { 188 if ((fd = (*driver) ()) >= 0) 189 break; 190 } 191 192 /* Check that a supported console driver was found */ 193 if (fd < 0) { 194 char cons_drivers[80] = { 0, }; 195 for (i = 0; i < ARRAY_SIZE(supported_drivers); i++) { 196 if (i) { 197 strcat(cons_drivers, ", "); 198 } 199 strcat(cons_drivers, supported_drivers[i]); 200 } 201 FatalError 202 ("%s: No console driver found\n\tSupported drivers: %s\n\t%s", 203 "xf86OpenConsole", cons_drivers, CHECK_DRIVER_MSG); 204 } 205 xf86Info.consoleFd = fd; 206 207 switch (xf86Info.consType) { 208 #ifdef PCCONS_SUPPORT 209 case PCCONS: 210 if (ioctl(xf86Info.consoleFd, CONSOLE_X_MODE_ON, 0) < 0) { 211 FatalError("%s: CONSOLE_X_MODE_ON failed (%s)\n%s", 212 "xf86OpenConsole", strerror(errno), 213 CHECK_DRIVER_MSG); 214 } 215 /* 216 * Hack to prevent keyboard hanging when syslogd closes 217 * /dev/console 218 */ 219 if ((devConsoleFd = open("/dev/console", O_WRONLY, 0)) < 0) { 220 xf86Msg(X_WARNING, 221 "xf86OpenConsole: couldn't open /dev/console (%s)\n", 222 strerror(errno)); 223 } 224 break; 225 #endif 226 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 227 case SYSCONS: 228 /* as of FreeBSD 2.2.8, syscons driver does not need the #1 vt 229 * switching anymore. Here we check for FreeBSD 3.1 and up. 230 * Add cases for other *BSD that behave the same. 231 */ 232 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 233 uname(&uts); 234 i = atof(uts.release) * 100; 235 if (i >= 310) 236 goto acquire_vt; 237 #endif 238 /* otherwise fall through */ 239 case PCVT: 240 #if !(defined(__NetBSD__) && (__NetBSD_Version__ >= 200000000)) 241 /* 242 * First activate the #1 VT. This is a hack to allow a server 243 * to be started while another one is active. There should be 244 * a better way. 245 */ 246 if (initialVT != 1) { 247 248 if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) != 0) { 249 xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n"); 250 } 251 sleep(1); 252 } 253 #endif 254 acquire_vt: 255 if (!xf86Info.ShareVTs) { 256 /* 257 * now get the VT 258 */ 259 SYSCALL(result = 260 ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno)); 261 if (result != 0) { 262 xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n"); 263 } 264 SYSCALL(result = 265 ioctl(xf86Info.consoleFd, VT_WAITACTIVE, 266 xf86Info.vtno)); 267 if (result != 0) { 268 xf86Msg(X_WARNING, 269 "xf86OpenConsole: VT_WAITACTIVE failed\n"); 270 } 271 272 OsSignal(SIGUSR1, xf86VTRequest); 273 274 vtmode.mode = VT_PROCESS; 275 vtmode.relsig = SIGUSR1; 276 vtmode.acqsig = SIGUSR1; 277 vtmode.frsig = SIGUSR1; 278 if (ioctl(xf86Info.consoleFd, VT_SETMODE, &vtmode) < 0) { 279 FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed"); 280 } 281 #if !defined(__OpenBSD__) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL) 282 if (ioctl(xf86Info.consoleFd, KDENABIO, 0) < 0) { 283 FatalError("xf86OpenConsole: KDENABIO failed (%s)", 284 strerror(errno)); 285 } 286 #endif 287 if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) { 288 FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed"); 289 } 290 } 291 else { /* xf86Info.ShareVTs */ 292 close(xf86Info.consoleFd); 293 } 294 break; 295 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */ 296 #ifdef WSCONS_SUPPORT 297 case WSCONS: 298 /* Nothing to do */ 299 break; 300 #endif 301 } 302 } 303 else { 304 /* serverGeneration != 1 */ 305 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 306 if (!xf86Info.ShareVTs && 307 (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT)) { 308 if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) { 309 xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n"); 310 } 311 } 312 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */ 313 } 314 return; 315 } 316 317 #ifdef PCCONS_SUPPORT 318 319 static int 320 xf86OpenPccons() 321 { 322 int fd = -1; 323 324 if ((fd = open(PCCONS_CONSOLE_DEV1, PCCONS_CONSOLE_MODE, 0)) 325 >= 0 || (fd = open(PCCONS_CONSOLE_DEV2, PCCONS_CONSOLE_MODE, 0)) 326 >= 0) { 327 if (ioctl(fd, CONSOLE_X_MODE_OFF, 0) < 0) { 328 FatalError("%s: CONSOLE_X_MODE_OFF failed (%s)\n%s\n%s", 329 "xf86OpenPccons", 330 strerror(errno), 331 "Was expecting pccons driver with X support", 332 CHECK_DRIVER_MSG); 333 } 334 xf86Info.consType = PCCONS; 335 xf86Msg(X_PROBED, "Using pccons driver with X support\n"); 336 } 337 return fd; 338 } 339 340 #endif /* PCCONS_SUPPORT */ 341 342 #ifdef SYSCONS_SUPPORT 343 344 static int 345 xf86OpenSyscons() 346 { 347 int fd = -1; 348 vtmode_t vtmode; 349 char vtname[12]; 350 long syscons_version; 351 MessageType from; 352 353 /* Check for syscons */ 354 if ((fd = open(SYSCONS_CONSOLE_DEV1, SYSCONS_CONSOLE_MODE, 0)) >= 0 355 || (fd = open(SYSCONS_CONSOLE_DEV2, SYSCONS_CONSOLE_MODE, 0)) >= 0) { 356 if (ioctl(fd, VT_GETMODE, &vtmode) >= 0) { 357 /* Get syscons version */ 358 if (ioctl(fd, CONS_GETVERS, &syscons_version) < 0) { 359 syscons_version = 0; 360 } 361 362 xf86Info.vtno = VTnum; 363 from = X_CMDLINE; 364 365 #ifdef VT_GETACTIVE 366 if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0) 367 initialVT = -1; 368 #endif 369 if (xf86Info.ShareVTs) 370 xf86Info.vtno = initialVT; 371 372 if (xf86Info.vtno == -1) { 373 /* 374 * For old syscons versions (<0x100), VT_OPENQRY returns 375 * the current VT rather than the next free VT. In this 376 * case, the server gets started on the current VT instead 377 * of the next free VT. 378 */ 379 380 #if 0 381 /* check for the fixed VT_OPENQRY */ 382 if (syscons_version >= 0x100) { 383 #endif 384 if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) { 385 /* No free VTs */ 386 xf86Info.vtno = -1; 387 } 388 #if 0 389 } 390 #endif 391 392 if (xf86Info.vtno == -1) { 393 /* 394 * All VTs are in use. If initialVT was found, use it. 395 */ 396 if (initialVT != -1) { 397 xf86Info.vtno = initialVT; 398 } 399 else { 400 if (syscons_version >= 0x100) { 401 FatalError("%s: Cannot find a free VT", 402 "xf86OpenSyscons"); 403 } 404 /* Should no longer reach here */ 405 FatalError("%s: %s %s\n\t%s %s", 406 "xf86OpenSyscons", 407 "syscons versions prior to 1.0 require", 408 "either the", 409 "server's stdin be a VT", 410 "or the use of the vtxx server option"); 411 } 412 } 413 from = X_PROBED; 414 } 415 416 close(fd); 417 snprintf(vtname, sizeof(vtname), "/dev/ttyv%01x", 418 xf86Info.vtno - 1); 419 if ((fd = open(vtname, SYSCONS_CONSOLE_MODE, 0)) < 0) { 420 FatalError("xf86OpenSyscons: Cannot open %s (%s)", 421 vtname, strerror(errno)); 422 } 423 if (ioctl(fd, VT_GETMODE, &vtmode) < 0) { 424 FatalError("xf86OpenSyscons: VT_GETMODE failed"); 425 } 426 xf86Info.consType = SYSCONS; 427 xf86Msg(X_PROBED, "Using syscons driver with X support"); 428 if (syscons_version >= 0x100) { 429 xf86ErrorF(" (version %ld.%ld)\n", syscons_version >> 8, 430 syscons_version & 0xFF); 431 } 432 else { 433 xf86ErrorF(" (version 0.x)\n"); 434 } 435 xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno); 436 } 437 else { 438 /* VT_GETMODE failed, probably not syscons */ 439 close(fd); 440 fd = -1; 441 } 442 } 443 return fd; 444 } 445 446 #endif /* SYSCONS_SUPPORT */ 447 448 #ifdef PCVT_SUPPORT 449 450 static int 451 xf86OpenPcvt() 452 { 453 /* This looks much like syscons, since pcvt is API compatible */ 454 int fd = -1; 455 vtmode_t vtmode; 456 char vtname[12], *vtprefix; 457 struct pcvtid pcvt_version; 458 459 #ifndef __OpenBSD__ 460 vtprefix = "/dev/ttyv"; 461 #else 462 vtprefix = "/dev/ttyC"; 463 #endif 464 465 fd = open(PCVT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0); 466 #ifdef WSCONS_PCVT_COMPAT_CONSOLE_DEV 467 if (fd < 0) { 468 fd = open(WSCONS_PCVT_COMPAT_CONSOLE_DEV, PCVT_CONSOLE_MODE, 0); 469 vtprefix = "/dev/ttyE"; 470 } 471 #endif 472 if (fd >= 0) { 473 if (ioctl(fd, VGAPCVTID, &pcvt_version) >= 0) { 474 if (ioctl(fd, VT_GETMODE, &vtmode) < 0) { 475 FatalError("%s: VT_GETMODE failed\n%s%s\n%s", 476 "xf86OpenPcvt", 477 "Found pcvt driver but X11 seems to be", 478 " not supported.", CHECK_DRIVER_MSG); 479 } 480 481 xf86Info.vtno = VTnum; 482 483 if (ioctl(fd, VT_GETACTIVE, &initialVT) < 0) 484 initialVT = -1; 485 486 if (xf86Info.vtno == -1) { 487 if (ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) { 488 /* No free VTs */ 489 xf86Info.vtno = -1; 490 } 491 492 if (xf86Info.vtno == -1) { 493 /* 494 * All VTs are in use. If initialVT was found, use it. 495 */ 496 if (initialVT != -1) { 497 xf86Info.vtno = initialVT; 498 } 499 else { 500 FatalError("%s: Cannot find a free VT", "xf86OpenPcvt"); 501 } 502 } 503 } 504 505 close(fd); 506 snprintf(vtname, sizeof(vtname), "%s%01x", vtprefix, 507 xf86Info.vtno - 1); 508 if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0) { 509 ErrorF("xf86OpenPcvt: Cannot open %s (%s)", 510 vtname, strerror(errno)); 511 xf86Info.vtno = initialVT; 512 snprintf(vtname, sizeof(vtname), "%s%01x", vtprefix, 513 xf86Info.vtno - 1); 514 if ((fd = open(vtname, PCVT_CONSOLE_MODE, 0)) < 0) { 515 FatalError("xf86OpenPcvt: Cannot open %s (%s)", 516 vtname, strerror(errno)); 517 } 518 } 519 if (ioctl(fd, VT_GETMODE, &vtmode) < 0) { 520 FatalError("xf86OpenPcvt: VT_GETMODE failed"); 521 } 522 xf86Info.consType = PCVT; 523 #ifdef WSCONS_SUPPORT 524 xf86Msg(X_PROBED, 525 "Using wscons driver on %s in pcvt compatibility mode " 526 "(version %d.%d)\n", vtname, 527 pcvt_version.rmajor, pcvt_version.rminor); 528 #else 529 xf86Msg(X_PROBED, "Using pcvt driver (version %d.%d)\n", 530 pcvt_version.rmajor, pcvt_version.rminor); 531 #endif 532 } 533 else { 534 /* Not pcvt */ 535 close(fd); 536 fd = -1; 537 } 538 } 539 return fd; 540 } 541 542 #endif /* PCVT_SUPPORT */ 543 544 #ifdef WSCONS_SUPPORT 545 546 static int 547 xf86OpenWScons() 548 { 549 int fd = -1; 550 int mode = WSDISPLAYIO_MODE_MAPPED; 551 int i; 552 char ttyname[16]; 553 554 /* XXX Is this ok? */ 555 for (i = 0; i < 8; i++) { 556 #if defined(__NetBSD__) 557 snprintf(ttyname, sizeof(ttyname), "/dev/ttyE%d", i); 558 #elif defined(__OpenBSD__) 559 snprintf(ttyname, sizeof(ttyname), "/dev/ttyC%x", i); 560 #endif 561 if ((fd = open(ttyname, 2)) != -1) 562 break; 563 } 564 if (fd != -1) { 565 if (ioctl(fd, WSDISPLAYIO_SMODE, &mode) < 0) { 566 FatalError("%s: WSDISPLAYIO_MODE_MAPPED failed (%s)\n%s", 567 "xf86OpenConsole", strerror(errno), CHECK_DRIVER_MSG); 568 } 569 xf86Info.consType = WSCONS; 570 xf86Msg(X_PROBED, "Using wscons driver\n"); 571 } 572 return fd; 573 } 574 575 #endif /* WSCONS_SUPPORT */ 576 577 void 578 xf86CloseConsole() 579 { 580 #if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) 581 struct vt_mode VT; 582 #endif 583 584 if (xf86Info.ShareVTs) 585 return; 586 587 switch (xf86Info.consType) { 588 #ifdef PCCONS_SUPPORT 589 case PCCONS: 590 ioctl(xf86Info.consoleFd, CONSOLE_X_MODE_OFF, 0); 591 break; 592 #endif /* PCCONS_SUPPORT */ 593 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 594 case SYSCONS: 595 case PCVT: 596 ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT); /* Back to text mode */ 597 if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1) { 598 VT.mode = VT_AUTO; 599 ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* dflt vt handling */ 600 } 601 #if !defined(__OpenBSD__) && !defined(USE_DEV_IO) && !defined(USE_I386_IOPL) 602 if (ioctl(xf86Info.consoleFd, KDDISABIO, 0) < 0) { 603 xf86FatalError("xf86CloseConsole: KDDISABIO failed (%s)", 604 strerror(errno)); 605 } 606 #endif 607 if (initialVT != -1) 608 ioctl(xf86Info.consoleFd, VT_ACTIVATE, initialVT); 609 break; 610 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */ 611 #ifdef WSCONS_SUPPORT 612 case WSCONS: 613 { 614 int mode = WSDISPLAYIO_MODE_EMUL; 615 616 ioctl(xf86Info.consoleFd, WSDISPLAYIO_SMODE, &mode); 617 break; 618 } 619 #endif 620 } 621 622 close(xf86Info.consoleFd); 623 #ifdef PCCONS_SUPPORT 624 if (devConsoleFd >= 0) 625 close(devConsoleFd); 626 #endif 627 return; 628 } 629 630 int 631 xf86ProcessArgument(int argc, char *argv[], int i) 632 { 633 /* 634 * Keep server from detaching from controlling tty. This is useful 635 * when debugging (so the server can receive keyboard signals. 636 */ 637 if (!strcmp(argv[i], "-keeptty")) { 638 KeepTty = TRUE; 639 return 1; 640 } 641 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 642 if ((argv[i][0] == 'v') && (argv[i][1] == 't')) { 643 if (sscanf(argv[i], "vt%2d", &VTnum) == 0 || VTnum < 1 || VTnum > 12) { 644 UseMsg(); 645 VTnum = -1; 646 return 0; 647 } 648 return 1; 649 } 650 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */ 651 return 0; 652 } 653 654 void 655 xf86UseMsg() 656 { 657 #if defined (SYSCONS_SUPPORT) || defined (PCVT_SUPPORT) 658 ErrorF("vtXX use the specified VT number (1-12)\n"); 659 #endif /* SYSCONS_SUPPORT || PCVT_SUPPORT */ 660 ErrorF("-keeptty "); 661 ErrorF("don't detach controlling tty (for debugging only)\n"); 662 return; 663 } 664 665 void 666 xf86OSInputThreadInit(void) 667 { 668 return; 669 }