"Fossies" - the Fresh Open Source Software Archive

Member "xorg-server-1.20.5/hw/xfree86/os-support/bsd/bsd_init.c" (30 May 2019, 20800 Bytes) of package /linux/misc/xorg-server-1.20.5.tar.bz2:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "bsd_init.c" see the Fossies "Dox" file reference documentation.

    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 existance of a supported console driver.
  106  * Any function returns either a valid file descriptor (driver probed
  107  * succesfully), -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 succesfully 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 }