虚拟控制台的切换过程

1.虚拟终端的切换在控制台软中断中运行，当按"ALT F1" 时，键盘中断设置变量want_console为0，然后激发控制台软中断(console_softint)，如果请求的控制台存在并且不等于当前控制台，这时调用change_console(want_console)切换控制台。

2.当前控制台就是直接操作物理屏幕的控制台，用fg_console变量指示。控制台的切换就是物理屏幕在虚拟控制台之间的切换，与CPU在进程之间的切换有些类似，当前物理显示屏的内容被保存在当前控制台的局部屏幕缓冲区之中，新控制台成为当前控制台，新当前控制台的局部屏幕被恢复到物理屏幕。当输出到背景控制台时, 文本被缓冲在该控制台的局部屏幕缓冲区中。

3.当应用程序在某个虚拟控制台中使显示设备处于图形状态时，内核无法正常切换到另一文本控制台，这时可以用KDSETMODE ioctl将控制台设置为KD_GRAPHICS状态，这样可防止控制台输出和切换操作。为了在图形状态下也能切换控制台，可以采用进程屏幕切换机制(VT_PROCESS)。当某个控制台被某个进程设置为VT_PROCESS模式时，当离开该控制台时, 内核向该进程生成"释放"信号(relsig)，当进入该控制台时，内核向该进程发送"获得"信号(acqsig)。该信息由vt_mode结构描述，用VT_SETMODE ioctl设置。

4.对于Ｘ窗口来说，Ｘ服务器启动时切换到第一个未分配的控制台来使用显示器，当离开该控制台时，内核在X服务器中产生信号，Ｘ服务器将显示器恢复为文本状态，然后向内核发出"显示器已释放"(VT_RELDISP)设备控制消息，内核再接着将显示器切换到新的控制台。反之，当从文本控制台进入X窗口的图形控制台时，内核保存当前文本控制台的屏幕现场后向Ｘ服务器发出信号，Ｘ服务器再将屏幕恢复到图形状态。

 

drivers/char/vt.c

/* 0x56 is 'V', to avoid collision with termios and kd */ #define VT_OPENQRY 0x5600 /* find available vt */ struct vt_mode { char mode; /* vt mode */ char waitv; /* if set, hang on writes if not active */ short relsig; /* signal to raise on release req */ short acqsig; /* signal to raise on acquisition */ short frsig; /* unused (set to 0) */ }; #define VT_GETMODE 0x5601 /* get mode of active vt */ #define VT_SETMODE 0x5602 /* set mode of active vt */ #define VT_AUTO 0x00 /* auto vt switching */ #define VT_PROCESS 0x01 /* process controls switching */ #define VT_ACKACQ 0x02 /* acknowledge switch */ struct vt_stat { unsigned short v_active; /* active vt */ unsigned short v_signal; /* signal to send */ unsigned short v_state; /* vt bitmask */ }; #define VT_GETSTATE 0x5603 /* get global vt state info */ #define VT_SENDSIG 0x5604 /* signal to send to bitmask of vts */ #define VT_RELDISP 0x5605 /* release display */ #define VT_ACTIVATE 0x5606 /* make vt active */ #define VT_WAITACTIVE 0x5607 /* wait for vt active */ #define VT_DISALLOCATE 0x5608 /* free memory associated to vt */ struct vt_sizes { unsigned short v_rows; /* number of rows */ unsigned short v_cols; /* number of columns */ unsigned short v_scrollsize; /* number of lines of scrollback */ }; #define VT_RESIZE 0x5609 /* set kernel's idea of screensize */ struct vt_consize { unsigned short v_rows; /* number of rows */ unsigned short v_cols; /* number of columns */ unsigned short v_vlin; /* number of pixel rows on screen */ unsigned short v_clin; /* number of pixel rows per character */ unsigned short v_vcol; /* number of pixel columns on screen */ unsigned short v_ccol; /* number of pixel columns per character */ }; #define VT_RESIZEX 0x560A /* set kernel's idea of screensize + more */ #define VT_LOCKSWITCH 0x560B /* disallow vt switching */ #define VT_UNLOCKSWITCH 0x560C /* allow vt switching */ extern struct vt_struct { int vc_num; /* The console number */ unsigned char vc_mode; /* KD_TEXT, ... */ struct vt_mode vt_mode; int vt_pid; int vt_newvt; wait_queue_head_t paste_wait; } *vt_cons[MAX_NR_CONSOLES]; extern inline void set_console(int nr) { want_console = nr; tasklet_schedule(&console_tasklet); } char vt_dont_switch; /* * Console (vt and kd) routines, as defined by USL SVR4 manual, and by * experimentation and study of X386 SYSV handling. * * One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and * /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console, * and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will * always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to * ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using * /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing * to the current console is done by the main ioctl code. */ struct vt_struct *vt_cons[MAX_NR_CONSOLES]; /* * Sometimes we want to wait until a particular VT has been activated. We * do it in a very simple manner. Everybody waits on a single queue and * get woken up at once. Those that are satisfied go on with their business, * while those not ready go back to sleep. Seems overkill to add a wait * to each vt just for this - usually this does nothing! */ static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue); #define vt_wake_waitactive() wake_up(&vt_activate_queue) #define switch_screen(x) redraw_screen(x, 1) #define update_screen(x) redraw_screen(x, 0) /* * Performs the front-end of a vt switch */ void change_console(unsigned int new_console) { if ((new_console == fg_console) || (vt_dont_switch)) return; if (!vc_cons_allocated(new_console)) return; /* * If this vt is in process mode, then we need to handshake with * that process before switching. Essentially, we store where that * vt wants to switch to and wait for it to tell us when it's done * (via VT_RELDISP ioctl). * * We also check to see if the controlling process still exists. * If it doesn't, we reset this vt to auto mode and continue. * This is a cheap way to track process control. The worst thing * that can happen is: we send a signal to a process, it dies, and * the switch gets "lost" waiting for a response; hopefully, the * user will try again, we'll detect the process is gone (unless * the user waits just the right amount of time :-) and revert the * vt to auto control. */ if (vt_cons[fg_console]->vt_mode.mode == VT_PROCESS) 如果当前控制台由进程完成切换 { /* * Send the signal as privileged - kill_proc() will * tell us if the process has gone or something else * is awry */ if (kill_proc(vt_cons[fg_console]->vt_pid, vt_cons[fg_console]->vt_mode.relsig, 1) == 0) 向当前控制台上的切换进程发送"释放控制台"内核信号 { /* * It worked. Mark the vt to switch to and * return. The process needs to send us a * VT_RELDISP ioctl to complete the switch. */ vt_cons[fg_console]->vt_newvt = new_console; return; } /* * The controlling process has died, so we revert back to * normal operation. In this case, we'll also change back * to KD_TEXT mode. I'm not sure if this is strictly correct * but it saves the agony when the X server dies and the screen * remains blanked due to KD_GRAPHICS! It would be nice to do * this outside of VT_PROCESS but there is no single process * to account for and tracking tty count may be undesirable. */ reset_vc(fg_console); /* * Fall through to normal (VT_AUTO) handling of the switch... */ } /* * Ignore all switches in KD_GRAPHICS+VT_AUTO mode */ if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS) return; complete_change_console(new_console); } /* * Performs the back end of a vt switch */ void complete_change_console(unsigned int new_console) { unsigned char old_vc_mode; last_console = fg_console; /* * If we're switching, we could be going from KD_GRAPHICS to * KD_TEXT mode or vice versa, which means we need to blank or * unblank the screen later. */ old_vc_mode = vt_cons[fg_console]->vc_mode; 保存当前控制台的显示模式 switch_screen(new_console); 切换到新的控制台屏幕 /* * If this new console is under process control, send it a signal * telling it that it has acquired. Also check if it has died and * clean up (similar to logic employed in change_console()) */ if (vt_cons[new_console]->vt_mode.mode == VT_PROCESS) 如果新控制台由进程完成切换 { /* * Send the signal as privileged - kill_proc() will * tell us if the process has gone or something else * is awry */ if (kill_proc(vt_cons[new_console]->vt_pid, vt_cons[new_console]->vt_mode.acqsig, 1) != 0) 向新控制台上的切换进程发送"获得控制台"的内核信号 { /* * The controlling process has died, so we revert back to * normal operation. In this case, we'll also change back * to KD_TEXT mode. I'm not sure if this is strictly correct * but it saves the agony when the X server dies and the screen * remains blanked due to KD_GRAPHICS! It would be nice to do * this outside of VT_PROCESS but there is no single process * to account for and tracking tty count may be undesirable. */ reset_vc(new_console); } } /* * We do this here because the controlling process above may have * gone, and so there is now a new vc_mode */ if (old_vc_mode != vt_cons[new_console]->vc_mode) 如果当前控制台显示模式不等于新控制台显示模式 { if (vt_cons[new_console]->vc_mode == KD_TEXT) 如果新控制台是文本模式 unblank_screen(); 打开屏幕 else 如果新控制台是图形模式 do_blank_screen(1); 关闭屏幕 } /* * Wake anyone waiting for their VT to activate */ vt_wake_waitactive(); return; } #define VT_IS_IN_USE(i) (console_driver.table[ i ] && console_driver.table[ i ]->count) #define VT_BUSY(i) (VT_IS_IN_USE(i) || i == fg_console || i == sel_cons) /* * We handle the console-specific ioctl's here. We allow the * capability to modify any console, not just the fg_console. */ int vt_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg) { int i, perm; unsigned int console; unsigned char ucval; struct kbd_struct * kbd; struct vt_struct *vt = (struct vt_struct *)tty->driver_data; console = vt->vc_num; if (!vc_cons_allocated(console)) /* impossible? */ return -ENOIOCTLCMD; /* * To have permissions to do most of the vt ioctls, we either have * to be the owner of the tty, or super-user. */ perm = 0; if (current->tty == tty || suser()) perm = 1; kbd = kbd_table + console; switch (cmd) { ... case KDSETMODE: 设置显示模式标志 /* * currently, setting the mode from KD_TEXT to KD_GRAPHICS * doesn't do a whole lot. i'm not sure if it should do any * restoration of modes or what... */ if (!perm) return -EPERM; switch (arg) { case KD_GRAPHICS: break; case KD_TEXT0: case KD_TEXT1: arg = KD_TEXT; case KD_TEXT: break; default: return -EINVAL; } if (vt_cons[console]->vc_mode == (unsigned char) arg) return 0; vt_cons[console]->vc_mode = (unsigned char) arg; if (console != fg_console) return 0; /* * explicitly blank/unblank the screen if switching modes */ if (arg == KD_TEXT) unblank_screen(); else do_blank_screen(1); return 0; case KDGETMODE: 取显示模式标志 ucval = vt_cons[console]->vc_mode; goto setint; ... /* * A process can indicate its willingness to accept signals * generated by pressing an appropriate key combination. * Thus, one can have a daemon that e.g. spawns a new console * upon a keypress and then changes to it. * Probably init should be changed to do this (and have a * field ks (`keyboard signal') in inittab describing the * desired action), so that the number of background daemons * does not increase. */ case KDSIGACCEPT: 设置信号热键 { extern int spawnpid, spawnsig; if (!perm || !capable(CAP_KILL)) return -EPERM; if (arg < 1 || arg > _NSIG || arg == SIGKILL) return -EINVAL; spawnpid = current->pid; spawnsig = arg; return 0; } case VT_SETMODE: 设置控制台进程切换模式 { struct vt_mode tmp; if (!perm) return -EPERM; if (copy_from_user(&tmp, (void*)arg, sizeof(struct vt_mode))) return -EFAULT; if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS) return -EINVAL; vt_cons[console]->vt_mode = tmp; /* the frsig is ignored, so we set it to 0 */ vt_cons[console]->vt_mode.frsig = 0; vt_cons[console]->vt_pid = current->pid; /* no switch is required -- saw@shade.msu.ru */ vt_cons[console]->vt_newvt = -1; return 0; } case VT_GETMODE: return copy_to_user((void*)arg, &(vt_cons[console]->vt_mode), sizeof(struct vt_mode)) ? -EFAULT : 0; /* * Returns global vt state. Note that VT 0 is always open, since * it's an alias for the current VT, and people can't use it here. * We cannot return state for more than 16 VTs, since v_state is short. */ case VT_GETSTATE: 取控制台的使用状态 { struct vt_stat *vtstat = (struct vt_stat *)arg; unsigned short state, mask; i = verify_area(VERIFY_WRITE,(void *)vtstat, sizeof(struct vt_stat)); if (i) return i; put_user(fg_console + 1, &vtstat->v_active); 输出当前活动的控制台 state = 1; /* /dev/tty0 is always open */ for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1) if (VT_IS_IN_USE(i)) state |= mask; return put_user(state, &vtstat->v_state); 输出正被使用控制台的集合 } /* * Returns the first available (non-opened) console. */ case VT_OPENQRY: 取第1个未被打开的控制台 for (i = 0; i < MAX_NR_CONSOLES; ++i) if (! VT_IS_IN_USE(i)) break; ucval = i < MAX_NR_CONSOLES ? (i+1) : -1; goto setint; /* * ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num, * with num >= 1 (switches to vt 0, our console, are not allowed, just * to preserve sanity). */ case VT_ACTIVATE: 切换控制台 if (!perm) return -EPERM; if (arg == 0 || arg > MAX_NR_CONSOLES) return -ENXIO; arg--; i = vc_allocate(arg); if (i) return i; set_console(arg); return 0; /* * wait until the specified VT has been activated */ case VT_WAITACTIVE: 等待特定的控制台被激活 if (!perm) return -EPERM; if (arg == 0 || arg > MAX_NR_CONSOLES) return -ENXIO; return vt_waitactive(arg-1); /* * If a vt is under process control, the kernel will not switch to it * immediately, but postpone the operation until the process calls this * ioctl, allowing the switch to complete. * * According to the X sources this is the behavior: * 0: pending switch-from not OK * 1: pending switch-from OK * 2: completed switch-to OK */ case VT_RELDISP: if (!perm) return -EPERM; if (vt_cons[console]->vt_mode.mode != VT_PROCESS) return -EINVAL; /* * Switching-from response */ if (vt_cons[console]->vt_newvt >= 0) { if (arg == 0) /* * Switch disallowed, so forget we were trying * to do it. */ vt_cons[console]->vt_newvt = -1; else { /* * The current vt has been released, so * complete the switch. */ int newvt = vt_cons[console]->vt_newvt; vt_cons[console]->vt_newvt = -1; i = vc_allocate(newvt); if (i) return i; /* * When we actually do the console switch, * make sure we are atomic with respect to * other console switches.. */ spin_lock_irq(&console_lock); complete_change_console(newvt); spin_unlock_irq(&console_lock); } } /* * Switched-to response */ else { /* * If it's just an ACK, ignore it */ if (arg != VT_ACKACQ) return -EINVAL; } return 0; /* * Disallocate memory associated to VT (but leave VT1) */ case VT_DISALLOCATE: 释放控制台内存 if (arg > MAX_NR_CONSOLES) return -ENXIO; if (arg == 0) { /* disallocate all unused consoles, but leave 0 */ for (i=1; i if (! VT_BUSY(i)) vc_disallocate(i); } else { /* disallocate a single console, if possible */ arg--; if (VT_BUSY(arg)) return -EBUSY; if (arg) /* leave 0 */ vc_disallocate(arg); } return 0; ... case VT_LOCKSWITCH: 禁止切换控制台 if (!suser()) return -EPERM; vt_dont_switch = 1; return 0; case VT_UNLOCKSWITCH: 允许切换控制台 if (!suser()) return -EPERM; vt_dont_switch = 0; return 0; ... default: return -ENOIOCTLCMD; } } /* * Sleeps until a vt is activated, or the task is interrupted. Returns * 0 if activation, -EINTR if interrupted. */ int vt_waitactive(int vt) { int retval; DECLARE_WAITQUEUE(wait, current); add_wait_queue(&vt_activate_queue, &wait); for (;;) { set_current_state(TASK_INTERRUPTIBLE); retval = 0; if (vt == fg_console) break; retval = -EINTR; if (signal_pending(current)) break; schedule(); } remove_wait_queue(&vt_activate_queue, &wait); current->state = TASK_RUNNING; return retval; } void reset_vc(unsigned int new_console) { vt_cons[new_console]->vc_mode = KD_TEXT; kbd_table[new_console].kbdmode = VC_XLATE; vt_cons[new_console]->vt_mode.mode = VT_AUTO; vt_cons[new_console]->vt_mode.waitv = 0; vt_cons[new_console]->vt_mode.relsig = 0; vt_cons[new_console]->vt_mode.acqsig = 0; vt_cons[new_console]->vt_mode.frsig = 0; vt_cons[new_console]->vt_pid = -1; vt_cons[new_console]->vt_newvt = -1; reset_palette (new_console) ; }

 

driver/char/console.c

/* * Redrawing of screen */ void redraw_screen(int new_console, int is_switch) { int redraw = 1; int currcons, old_console; if (!vc_cons_allocated(new_console)) { /* strange ... */ /* printk("redraw_screen: tty %d not allocated ??/n", new_console+1); */ return; } if (is_switch) { currcons = fg_console; hide_cursor(currcons); if (fg_console != new_console) { struct vc_data **display = vc_cons[new_console].d->vc_display_fg; 取新控制台的主控制台指针 old_console = (*display) ? (*display)->vc_num : fg_console; 从主控制台指针取显示控制台或者前景控制台 *display = vc_cons[new_console].d; 将新控制台设为主控制台 fg_console = new_console; 设置前景控制台为新控制台 currcons = old_console; if (!IS_VISIBLE) { 如果原来的控制台现在变得不可见 save_screen(currcons); 保存当前设置屏幕到原控制台局部缓冲区 set_origin(currcons); 设置屏幕缓冲区为局部缓冲区 } currcons = new_console; if (old_console == new_console) redraw = 0; } } else { currcons = new_console; hide_cursor(currcons); } if (redraw) { int update; set_origin(currcons); update = sw->con_switch(vc_cons[currcons].d); 加载局部屏幕缓冲区到物理屏幕 set_palette(currcons); 加载调色板 if (update && vcmode != KD_GRAPHICS) do_update_region(currcons, origin, screenbuf_size/2); 重绘整个屏幕 } set_cursor(currcons); 加载光标 if (is_switch) { set_leds(); compute_shiftstate(); } } int vc_allocate(unsigned int currcons) /* return 0 on success */ { if (currcons >= MAX_NR_CONSOLES) return -ENXIO; if (!vc_cons[currcons].d) { long p, q; /* prevent users from taking too much memory */ if (currcons >= MAX_NR_USER_CONSOLES && !capable(CAP_SYS_RESOURCE)) return -EPERM; /* due to the granularity of kmalloc, we waste some memory here */ /* the alloc is done in two steps, to optimize the common situation of a 25x80 console (structsize=216, screenbuf_size=4000) */ /* although the numbers above are not valid since long ago, the point is still up-to-date and the comment still has its value even if only as a historical artifact. --mj, July 1998 */ p = (long) kmalloc(structsize, GFP_KERNEL); if (!p) return -ENOMEM; vc_cons[currcons].d = (struct vc_data *)p; vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data)); visual_init(currcons, 1); if (!*vc_cons[currcons].d->vc_uni_pagedir_loc) con_set_default_unimap(currcons); q = (long)kmalloc(screenbuf_size, GFP_KERNEL); if (!q) { kfree((char *) p); vc_cons[currcons].d = NULL; vt_cons[currcons] = NULL; return -ENOMEM; } screenbuf = (unsigned short *) q; kmalloced = 1; vc_init(currcons, video_num_lines, video_num_columns, 1); if (!pm_con) { pm_con = pm_register(PM_SYS_DEV, PM_SYS_VGA, pm_con_request); } } return 0; }

 

driver/video/vgacon.c

static int vgacon_switch(struct vc_data *c) { /* * We need to save screen size here as it's the only way * we can spot the screen has been resized and we need to * set size of freshly allocated screens ourselves. */ vga_video_num_columns = c->vc_cols; vga_video_num_lines = c->vc_rows; if (!vga_is_gfx) scr_memcpyw_to((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf, c->vc_screenbuf_size); return 0; /* Redrawing not needed */ }