/*
* linux/drivers/char/vt.c
*
* Copyright (C) 1992 obz under the linux copyright
*
* Dynamic diacritical handling - aeb@cwi.nl - Dec 1993
* Dynamic keymap and string allocation - aeb@cwi.nl - May 1994
* Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995
* Some code moved for less code duplication - Andi Kleen - Mar 1997
*/
#include <linux/config.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/timer.h>
#include <linux/kernel.h>
#include <linux/kd.h>
#include <linux/vt.h>
#include <linux/string.h>
#include <linux/malloc.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/console.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#if defined(__mc68000__) || defined(CONFIG_APUS)
#include <asm/machdep.h>
#endif
#include <linux/kbd_kern.h>
#include <linux/vt_kern.h>
#include <linux/kbd_diacr.h>
#include <linux/selection.h>
#ifdef CONFIG_FB_COMPAT_XPMAC
#include <asm/vc_ioctl.h>
#endif /* CONFIG_FB_COMPAT_XPMAC */
char vt_dont_switch;
extern struct tty_driver console_driver;
#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)
/*
* 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];
/* Keyboard type: Default is KB_101, but can be set by machine
* specific code.
*/
unsigned char keyboard_type = KB_101;
#if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips__) && !defined(__arm__) && !defined(__sh__)
asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int on);
#endif
unsigned int video_font_height;
unsigned int default_font_height;
unsigned int video_scan_lines;
/*
* these are the valid i/o ports we're allowed to change. they map all the
* video ports
*/
#define GPFIRST 0x3b4
#define GPLAST 0x3df
#define GPNUM (GPLAST - GPFIRST + 1)
/*
* Generates sound of some frequency for some number of clock ticks
*
* If freq is 0, will turn off sound, else will turn it on for that time.
* If msec is 0, will return immediately, else will sleep for msec time, then
* turn sound off.
*
* We also return immediately, which is what was implied within the X
* comments - KDMKTONE doesn't put the process to sleep.
*/
#if defined(__i386__) || defined(__alpha__) || defined(__powerpc__) \
|| (defined(__mips__) && !defined(CONFIG_SGI_IP22)) \
|| (defined(__arm__) && defined(CONFIG_HOST_FOOTBRIDGE))
static void
101 kd_nosound(unsigned long ignored)
{
/* disable counter 2 */
outb(inb_p(0x61)&0xFC, 0x61);
105 return;
}
void
109 _kd_mksound(unsigned int hz, unsigned int ticks)
{
static struct timer_list sound_timer = { function: kd_nosound };
unsigned int count = 0;
unsigned long flags;
115 if (hz > 20 && hz < 32767)
count = 1193180 / hz;
save_flags(flags);
cli();
del_timer(&sound_timer);
121 if (count) {
/* enable counter 2 */
outb_p(inb_p(0x61)|3, 0x61);
/* set command for counter 2, 2 byte write */
outb_p(0xB6, 0x43);
/* select desired HZ */
outb_p(count & 0xff, 0x42);
outb((count >> 8) & 0xff, 0x42);
130 if (ticks) {
sound_timer.expires = jiffies+ticks;
add_timer(&sound_timer);
}
134 } else
kd_nosound(0);
restore_flags(flags);
137 return;
}
#else
void
_kd_mksound(unsigned int hz, unsigned int ticks)
{
}
#endif
void (*kd_mksound)(unsigned int hz, unsigned int ticks) = _kd_mksound;
#define i (tmp.kb_index)
#define s (tmp.kb_table)
#define v (tmp.kb_value)
static inline int
156 do_kdsk_ioctl(int cmd, struct kbentry *user_kbe, int perm, struct kbd_struct *kbd)
{
struct kbentry tmp;
ushort *key_map, val, ov;
161 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
162 return -EFAULT;
163 if (i >= NR_KEYS || s >= MAX_NR_KEYMAPS)
164 return -EINVAL;
166 switch (cmd) {
167 case KDGKBENT:
key_map = key_maps[s];
169 if (key_map) {
val = U(key_map[i]);
171 if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
val = K_HOLE;
173 } else
val = (i ? K_HOLE : K_NOSUCHMAP);
175 return put_user(val, &user_kbe->kb_value);
176 case KDSKBENT:
177 if (!perm)
178 return -EPERM;
179 if (!i && v == K_NOSUCHMAP) {
/* disallocate map */
key_map = key_maps[s];
182 if (s && key_map) {
key_maps[s] = 0;
184 if (key_map[0] == U(K_ALLOCATED)) {
kfree(key_map);
keymap_count--;
}
}
189 break;
}
192 if (KTYP(v) < NR_TYPES) {
193 if (KVAL(v) > max_vals[KTYP(v)])
194 return -EINVAL;
} else
196 if (kbd->kbdmode != VC_UNICODE)
197 return -EINVAL;
/* ++Geert: non-PC keyboards may generate keycode zero */
#if !defined(__mc68000__) && !defined(__powerpc__)
/* assignment to entry 0 only tests validity of args */
202 if (!i)
203 break;
#endif
206 if (!(key_map = key_maps[s])) {
int j;
if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
210 !capable(CAP_SYS_RESOURCE))
211 return -EPERM;
key_map = (ushort *) kmalloc(sizeof(plain_map),
GFP_KERNEL);
215 if (!key_map)
216 return -ENOMEM;
key_maps[s] = key_map;
key_map[0] = U(K_ALLOCATED);
219 for (j = 1; j < NR_KEYS; j++)
key_map[j] = U(K_HOLE);
keymap_count++;
}
ov = U(key_map[i]);
224 if (v == ov)
225 break; /* nothing to do */
/*
* Attention Key.
*/
229 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN))
230 return -EPERM;
key_map[i] = U(v);
232 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
compute_shiftstate();
234 break;
}
236 return 0;
}
#undef i
#undef s
#undef v
static inline int
243 do_kbkeycode_ioctl(int cmd, struct kbkeycode *user_kbkc, int perm)
{
struct kbkeycode tmp;
int kc = 0;
248 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
249 return -EFAULT;
250 switch (cmd) {
251 case KDGETKEYCODE:
kc = getkeycode(tmp.scancode);
253 if (kc >= 0)
kc = put_user(kc, &user_kbkc->keycode);
255 break;
256 case KDSETKEYCODE:
257 if (!perm)
258 return -EPERM;
kc = setkeycode(tmp.scancode, tmp.keycode);
260 break;
}
262 return kc;
}
static inline int
266 do_kdgkb_ioctl(int cmd, struct kbsentry *user_kdgkb, int perm)
{
struct kbsentry tmp;
char *p;
u_char *q;
int sz;
int delta;
char *first_free, *fj, *fnw;
int i, j, k;
/* we mostly copy too much here (512bytes), but who cares ;) */
277 if (copy_from_user(&tmp, user_kdgkb, sizeof(struct kbsentry)))
278 return -EFAULT;
tmp.kb_string[sizeof(tmp.kb_string)-1] = '\0';
280 if (tmp.kb_func >= MAX_NR_FUNC)
281 return -EINVAL;
i = tmp.kb_func;
284 switch (cmd) {
285 case KDGKBSENT:
sz = sizeof(tmp.kb_string) - 1; /* sz should have been
a struct member */
q = user_kdgkb->kb_string;
p = func_table[i];
290 if(p)
291 for ( ; *p && sz; p++, sz--)
put_user(*p, q++);
put_user('\0', q);
294 return ((p && *p) ? -EOVERFLOW : 0);
295 case KDSKBSENT:
296 if (!perm)
297 return -EPERM;
q = func_table[i];
first_free = funcbufptr + (funcbufsize - funcbufleft);
301 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
;
303 if (j < MAX_NR_FUNC)
fj = func_table[j];
305 else
fj = first_free;
delta = (q ? -strlen(q) : 1) + strlen(tmp.kb_string);
309 if (delta <= funcbufleft) { /* it fits in current buf */
310 if (j < MAX_NR_FUNC) {
memmove(fj + delta, fj, first_free - fj);
312 for (k = j; k < MAX_NR_FUNC; k++)
313 if (func_table[k])
func_table[k] += delta;
}
316 if (!q)
func_table[i] = fj;
funcbufleft -= delta;
319 } else { /* allocate a larger buffer */
sz = 256;
321 while (sz < funcbufsize - funcbufleft + delta)
sz <<= 1;
fnw = (char *) kmalloc(sz, GFP_KERNEL);
324 if(!fnw)
325 return -ENOMEM;
327 if (!q)
func_table[i] = fj;
329 if (fj > funcbufptr)
memmove(fnw, funcbufptr, fj - funcbufptr);
331 for (k = 0; k < j; k++)
332 if (func_table[k])
func_table[k] = fnw + (func_table[k] - funcbufptr);
335 if (first_free > fj) {
memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
337 for (k = j; k < MAX_NR_FUNC; k++)
338 if (func_table[k])
func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
}
341 if (funcbufptr != func_buf)
kfree(funcbufptr);
funcbufptr = fnw;
funcbufleft = funcbufleft - delta + sz - funcbufsize;
funcbufsize = sz;
}
strcpy(func_table[i], tmp.kb_string);
348 break;
}
350 return 0;
}
static inline int
354 do_fontx_ioctl(int cmd, struct consolefontdesc *user_cfd, int perm)
{
struct consolefontdesc cfdarg;
struct console_font_op op;
int i;
360 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc)))
361 return -EFAULT;
363 switch (cmd) {
364 case PIO_FONTX:
365 if (!perm)
366 return -EPERM;
op.op = KD_FONT_OP_SET;
op.flags = KD_FONT_FLAG_OLD;
op.width = 8;
op.height = cfdarg.charheight;
op.charcount = cfdarg.charcount;
op.data = cfdarg.chardata;
373 return con_font_op(fg_console, &op);
374 case GIO_FONTX: {
op.op = KD_FONT_OP_GET;
op.flags = KD_FONT_FLAG_OLD;
op.width = 8;
op.height = cfdarg.charheight;
op.charcount = cfdarg.charcount;
op.data = cfdarg.chardata;
i = con_font_op(fg_console, &op);
382 if (i)
383 return i;
cfdarg.charheight = op.height;
cfdarg.charcount = op.charcount;
386 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc)))
387 return -EFAULT;
388 return 0;
}
}
391 return -EINVAL;
}
static inline int
395 do_unimap_ioctl(int cmd, struct unimapdesc *user_ud,int perm)
{
struct unimapdesc tmp;
int i = 0;
400 if (copy_from_user(&tmp, user_ud, sizeof tmp))
401 return -EFAULT;
402 if (tmp.entries) {
i = verify_area(VERIFY_WRITE, tmp.entries,
tmp.entry_ct*sizeof(struct unipair));
405 if (i) return i;
}
407 switch (cmd) {
408 case PIO_UNIMAP:
409 if (!perm)
410 return -EPERM;
411 return con_set_unimap(fg_console, tmp.entry_ct, tmp.entries);
412 case GIO_UNIMAP:
413 return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries);
}
415 return 0;
}
/*
* We handle the console-specific ioctl's here. We allow the
* capability to modify any console, not just the fg_console.
*/
422 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;
433 if (!vc_cons_allocated(console)) /* impossible? */
434 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;
441 if (current->tty == tty || suser())
perm = 1;
kbd = kbd_table + console;
445 switch (cmd) {
446 case KIOCSOUND:
447 if (!perm)
448 return -EPERM;
449 if (arg)
arg = 1193180 / arg;
kd_mksound(arg, 0);
452 return 0;
454 case KDMKTONE:
455 if (!perm)
456 return -EPERM;
{
unsigned int ticks, count;
/*
* Generate the tone for the appropriate number of ticks.
* If the time is zero, turn off sound ourselves.
*/
ticks = HZ * ((arg >> 16) & 0xffff) / 1000;
count = ticks ? (arg & 0xffff) : 0;
466 if (count)
count = 1193180 / count;
kd_mksound(count, ticks);
469 return 0;
}
472 case KDGKBTYPE:
/*
* this is naive.
*/
ucval = keyboard_type;
477 goto setchar;
#if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips__) && !defined(__arm__) && !defined(__sh__)
/*
* These cannot be implemented on any machine that implements
* ioperm() in user level (such as Alpha PCs).
*/
484 case KDADDIO:
485 case KDDELIO:
/*
* KDADDIO and KDDELIO may be able to add ports beyond what
* we reject here, but to be safe...
*/
490 if (arg < GPFIRST || arg > GPLAST)
491 return -EINVAL;
492 return sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
494 case KDENABIO:
495 case KDDISABIO:
return sys_ioperm(GPFIRST, GPNUM,
497 (cmd == KDENABIO)) ? -ENXIO : 0;
#endif
#if defined(__mc68000__) || defined(CONFIG_APUS)
/* Linux/m68k interface for setting the keyboard delay/repeat rate */
case KDKBDREP:
{
struct kbd_repeat kbrep;
if (!mach_kbdrate) return( -EINVAL );
if (!suser()) return( -EPERM );
if (copy_from_user(&kbrep, (void *)arg,
sizeof(struct kbd_repeat)))
return -EFAULT;
if ((i = mach_kbdrate( &kbrep ))) return( i );
if (copy_to_user((void *)arg, &kbrep,
sizeof(struct kbd_repeat)))
return -EFAULT;
return 0;
}
#endif
521 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...
*/
527 if (!perm)
528 return -EPERM;
529 switch (arg) {
530 case KD_GRAPHICS:
531 break;
532 case KD_TEXT0:
533 case KD_TEXT1:
arg = KD_TEXT;
535 case KD_TEXT:
536 break;
537 default:
538 return -EINVAL;
}
540 if (vt_cons[console]->vc_mode == (unsigned char) arg)
541 return 0;
vt_cons[console]->vc_mode = (unsigned char) arg;
543 if (console != fg_console)
544 return 0;
/*
* explicitly blank/unblank the screen if switching modes
*/
548 if (arg == KD_TEXT)
unblank_screen();
550 else
do_blank_screen(1);
552 return 0;
554 case KDGETMODE:
ucval = vt_cons[console]->vc_mode;
556 goto setint;
558 case KDMAPDISP:
559 case KDUNMAPDISP:
/*
* these work like a combination of mmap and KDENABIO.
* this could be easily finished.
*/
564 return -EINVAL;
566 case KDSKBMODE:
567 if (!perm)
568 return -EPERM;
569 switch(arg) {
570 case K_RAW:
kbd->kbdmode = VC_RAW;
572 break;
573 case K_MEDIUMRAW:
kbd->kbdmode = VC_MEDIUMRAW;
575 break;
576 case K_XLATE:
kbd->kbdmode = VC_XLATE;
compute_shiftstate();
579 break;
580 case K_UNICODE:
kbd->kbdmode = VC_UNICODE;
compute_shiftstate();
583 break;
584 default:
585 return -EINVAL;
}
587 if (tty->ldisc.flush_buffer)
tty->ldisc.flush_buffer(tty);
589 return 0;
591 case KDGKBMODE:
ucval = ((kbd->kbdmode == VC_RAW) ? K_RAW :
(kbd->kbdmode == VC_MEDIUMRAW) ? K_MEDIUMRAW :
(kbd->kbdmode == VC_UNICODE) ? K_UNICODE :
K_XLATE);
596 goto setint;
/* this could be folded into KDSKBMODE, but for compatibility
reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */
600 case KDSKBMETA:
601 switch(arg) {
602 case K_METABIT:
clr_vc_kbd_mode(kbd, VC_META);
604 break;
605 case K_ESCPREFIX:
set_vc_kbd_mode(kbd, VC_META);
607 break;
608 default:
609 return -EINVAL;
}
611 return 0;
613 case KDGKBMETA:
ucval = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT);
setint:
616 return put_user(ucval, (int *)arg);
618 case KDGETKEYCODE:
619 case KDSETKEYCODE:
620 if(!capable(CAP_SYS_ADMIN))
perm=0;
622 return do_kbkeycode_ioctl(cmd, (struct kbkeycode *)arg, perm);
624 case KDGKBENT:
625 case KDSKBENT:
626 return do_kdsk_ioctl(cmd, (struct kbentry *)arg, perm, kbd);
628 case KDGKBSENT:
629 case KDSKBSENT:
630 return do_kdgkb_ioctl(cmd, (struct kbsentry *)arg, perm);
632 case KDGKBDIACR:
{
struct kbdiacrs *a = (struct kbdiacrs *)arg;
636 if (put_user(accent_table_size, &a->kb_cnt))
637 return -EFAULT;
638 if (copy_to_user(a->kbdiacr, accent_table, accent_table_size*sizeof(struct kbdiacr)))
639 return -EFAULT;
640 return 0;
}
643 case KDSKBDIACR:
{
struct kbdiacrs *a = (struct kbdiacrs *)arg;
unsigned int ct;
648 if (!perm)
649 return -EPERM;
650 if (get_user(ct,&a->kb_cnt))
651 return -EFAULT;
652 if (ct >= MAX_DIACR)
653 return -EINVAL;
accent_table_size = ct;
655 if (copy_from_user(accent_table, a->kbdiacr, ct*sizeof(struct kbdiacr)))
656 return -EFAULT;
657 return 0;
}
/* the ioctls below read/set the flags usually shown in the leds */
/* don't use them - they will go away without warning */
662 case KDGKBLED:
ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4);
664 goto setchar;
666 case KDSKBLED:
667 if (!perm)
668 return -EPERM;
669 if (arg & ~0x77)
670 return -EINVAL;
kbd->ledflagstate = (arg & 7);
kbd->default_ledflagstate = ((arg >> 4) & 7);
set_leds();
674 return 0;
/* the ioctls below only set the lights, not the functions */
/* for those, see KDGKBLED and KDSKBLED above */
678 case KDGETLED:
ucval = getledstate();
setchar:
681 return put_user(ucval, (char*)arg);
683 case KDSETLED:
684 if (!perm)
685 return -EPERM;
setledstate(kbd, arg);
687 return 0;
/*
* 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.
*/
699 case KDSIGACCEPT:
{
extern int spawnpid, spawnsig;
702 if (!perm || !capable(CAP_KILL))
703 return -EPERM;
704 if (arg < 1 || arg > _NSIG || arg == SIGKILL)
705 return -EINVAL;
spawnpid = current->pid;
spawnsig = arg;
708 return 0;
}
711 case VT_SETMODE:
{
struct vt_mode tmp;
715 if (!perm)
716 return -EPERM;
717 if (copy_from_user(&tmp, (void*)arg, sizeof(struct vt_mode)))
718 return -EFAULT;
719 if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS)
720 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;
727 return 0;
}
730 case VT_GETMODE:
return copy_to_user((void*)arg, &(vt_cons[console]->vt_mode),
732 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.
*/
739 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));
745 if (i)
746 return i;
put_user(fg_console + 1, &vtstat->v_active);
state = 1; /* /dev/tty0 is always open */
749 for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; ++i, mask <<= 1)
750 if (VT_IS_IN_USE(i))
state |= mask;
752 return put_user(state, &vtstat->v_state);
}
/*
* Returns the first available (non-opened) console.
*/
758 case VT_OPENQRY:
759 for (i = 0; i < MAX_NR_CONSOLES; ++i)
760 if (! VT_IS_IN_USE(i))
761 break;
ucval = i < MAX_NR_CONSOLES ? (i+1) : -1;
763 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).
*/
770 case VT_ACTIVATE:
771 if (!perm)
772 return -EPERM;
773 if (arg == 0 || arg > MAX_NR_CONSOLES)
774 return -ENXIO;
arg--;
i = vc_allocate(arg);
777 if (i)
778 return i;
set_console(arg);
780 return 0;
/*
* wait until the specified VT has been activated
*/
785 case VT_WAITACTIVE:
786 if (!perm)
787 return -EPERM;
788 if (arg == 0 || arg > MAX_NR_CONSOLES)
789 return -ENXIO;
790 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
*/
802 case VT_RELDISP:
803 if (!perm)
804 return -EPERM;
805 if (vt_cons[console]->vt_mode.mode != VT_PROCESS)
806 return -EINVAL;
/*
* Switching-from response
*/
811 if (vt_cons[console]->vt_newvt >= 0)
{
813 if (arg == 0)
/*
* Switch disallowed, so forget we were trying
* to do it.
*/
vt_cons[console]->vt_newvt = -1;
820 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);
829 if (i)
830 return i;
/*
* When we actually do the console switch,
* make sure we are atomic with respect to
* other console switches..
*/
836 spin_lock_irq(&console_lock);
complete_change_console(newvt);
838 spin_unlock_irq(&console_lock);
}
}
/*
* Switched-to response
*/
845 else
{
/*
* If it's just an ACK, ignore it
*/
850 if (arg != VT_ACKACQ)
851 return -EINVAL;
}
854 return 0;
/*
* Disallocate memory associated to VT (but leave VT1)
*/
859 case VT_DISALLOCATE:
860 if (arg > MAX_NR_CONSOLES)
861 return -ENXIO;
862 if (arg == 0) {
/* disallocate all unused consoles, but leave 0 */
864 for (i=1; i<MAX_NR_CONSOLES; i++)
865 if (! VT_BUSY(i))
vc_disallocate(i);
867 } else {
/* disallocate a single console, if possible */
arg--;
870 if (VT_BUSY(arg))
871 return -EBUSY;
872 if (arg) /* leave 0 */
vc_disallocate(arg);
}
875 return 0;
877 case VT_RESIZE:
{
struct vt_sizes *vtsizes = (struct vt_sizes *) arg;
ushort ll,cc;
881 if (!perm)
882 return -EPERM;
i = verify_area(VERIFY_READ, (void *)vtsizes, sizeof(struct vt_sizes));
884 if (i)
885 return i;
get_user(ll, &vtsizes->v_rows);
get_user(cc, &vtsizes->v_cols);
888 return vc_resize_all(ll, cc);
}
891 case VT_RESIZEX:
{
struct vt_consize *vtconsize = (struct vt_consize *) arg;
ushort ll,cc,vlin,clin,vcol,ccol;
895 if (!perm)
896 return -EPERM;
i = verify_area(VERIFY_READ, (void *)vtconsize, sizeof(struct vt_consize));
898 if (i)
899 return i;
get_user(ll, &vtconsize->v_rows);
get_user(cc, &vtconsize->v_cols);
get_user(vlin, &vtconsize->v_vlin);
get_user(clin, &vtconsize->v_clin);
get_user(vcol, &vtconsize->v_vcol);
get_user(ccol, &vtconsize->v_ccol);
vlin = vlin ? vlin : video_scan_lines;
907 if ( clin )
{
909 if ( ll )
{
911 if ( ll != vlin/clin )
912 return -EINVAL; /* Parameters don't add up */
}
914 else
ll = vlin/clin;
}
917 if ( vcol && ccol )
{
919 if ( cc )
{
921 if ( cc != vcol/ccol )
922 return -EINVAL;
}
924 else
cc = vcol/ccol;
}
928 if ( clin > 32 )
929 return -EINVAL;
931 if ( vlin )
video_scan_lines = vlin;
933 if ( clin )
video_font_height = clin;
936 return vc_resize_all(ll, cc);
}
939 case PIO_FONT: {
struct console_font_op op;
941 if (!perm)
942 return -EPERM;
op.op = KD_FONT_OP_SET;
op.flags = KD_FONT_FLAG_OLD | KD_FONT_FLAG_DONT_RECALC; /* Compatibility */
op.width = 8;
op.height = 0;
op.charcount = 256;
op.data = (char *) arg;
949 return con_font_op(fg_console, &op);
}
952 case GIO_FONT: {
struct console_font_op op;
op.op = KD_FONT_OP_GET;
op.flags = KD_FONT_FLAG_OLD;
op.width = 8;
op.height = 32;
op.charcount = 256;
op.data = (char *) arg;
960 return con_font_op(fg_console, &op);
}
963 case PIO_CMAP:
964 if (!perm)
965 return -EPERM;
966 return con_set_cmap((char *)arg);
968 case GIO_CMAP:
969 return con_get_cmap((char *)arg);
971 case PIO_FONTX:
972 case GIO_FONTX:
973 return do_fontx_ioctl(cmd, (struct consolefontdesc *)arg, perm);
975 case PIO_FONTRESET:
{
977 if (!perm)
978 return -EPERM;
#ifdef BROKEN_GRAPHICS_PROGRAMS
/* With BROKEN_GRAPHICS_PROGRAMS defined, the default
font is not saved. */
983 return -ENOSYS;
#else
{
struct console_font_op op;
op.op = KD_FONT_OP_SET_DEFAULT;
op.data = NULL;
i = con_font_op(fg_console, &op);
if (i) return i;
con_set_default_unimap(fg_console);
return 0;
}
#endif
}
997 case KDFONTOP: {
struct console_font_op op;
999 if (copy_from_user(&op, (void *) arg, sizeof(op)))
1000 return -EFAULT;
1001 if (!perm && op.op != KD_FONT_OP_GET)
1002 return -EPERM;
i = con_font_op(console, &op);
1004 if (i) return i;
1005 if (copy_to_user((void *) arg, &op, sizeof(op)))
1006 return -EFAULT;
1007 return 0;
}
1010 case PIO_SCRNMAP:
1011 if (!perm)
1012 return -EPERM;
1013 return con_set_trans_old((unsigned char *)arg);
1015 case GIO_SCRNMAP:
1016 return con_get_trans_old((unsigned char *)arg);
1018 case PIO_UNISCRNMAP:
1019 if (!perm)
1020 return -EPERM;
1021 return con_set_trans_new((unsigned short *)arg);
1023 case GIO_UNISCRNMAP:
1024 return con_get_trans_new((unsigned short *)arg);
1026 case PIO_UNIMAPCLR:
{ struct unimapinit ui;
1028 if (!perm)
1029 return -EPERM;
i = copy_from_user(&ui, (void *)arg, sizeof(struct unimapinit));
1031 if (i) return -EFAULT;
con_clear_unimap(fg_console, &ui);
1033 return 0;
}
1036 case PIO_UNIMAP:
1037 case GIO_UNIMAP:
1038 return do_unimap_ioctl(cmd, (struct unimapdesc *)arg, perm);
1040 case VT_LOCKSWITCH:
1041 if (!suser())
1042 return -EPERM;
vt_dont_switch = 1;
1044 return 0;
1045 case VT_UNLOCKSWITCH:
1046 if (!suser())
1047 return -EPERM;
vt_dont_switch = 0;
1049 return 0;
#ifdef CONFIG_FB_COMPAT_XPMAC
case VC_GETMODE:
{
struct vc_mode mode;
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(struct vc_mode));
if (i == 0)
i = console_getmode(&mode);
if (i)
return i;
if (copy_to_user((void *) arg, &mode, sizeof(mode)))
return -EFAULT;
return 0;
}
case VC_SETMODE:
case VC_INQMODE:
{
struct vc_mode mode;
if (!perm)
return -EPERM;
i = verify_area(VERIFY_READ, (void *) arg,
sizeof(struct vc_mode));
if (i)
return i;
if (copy_from_user(&mode, (void *) arg, sizeof(mode)))
return -EFAULT;
return console_setmode(&mode, cmd == VC_SETMODE);
}
case VC_SETCMAP:
{
unsigned char cmap[3][256], *p;
int n_entries, cmap_size, i, j;
if (!perm)
return -EPERM;
if (arg == (unsigned long) VC_POWERMODE_INQUIRY
|| arg <= VESA_POWERDOWN) {
/* compatibility hack: VC_POWERMODE
was changed from 0x766a to 0x766c */
return console_powermode((int) arg);
}
i = verify_area(VERIFY_READ, (void *) arg,
sizeof(int));
if (i)
return i;
if (get_user(cmap_size, (int *) arg))
return -EFAULT;
if (cmap_size % 3)
return -EINVAL;
n_entries = cmap_size / 3;
if ((unsigned) n_entries > 256)
return -EINVAL;
p = (unsigned char *) (arg + sizeof(int));
for (j = 0; j < n_entries; ++j)
for (i = 0; i < 3; ++i)
if (get_user(cmap[i][j], p++))
return -EFAULT;
return console_setcmap(n_entries, cmap[0],
cmap[1], cmap[2]);
}
case VC_GETCMAP:
/* not implemented yet */
return -ENOIOCTLCMD;
case VC_POWERMODE:
if (!perm)
return -EPERM;
return console_powermode((int) arg);
#endif /* CONFIG_FB_COMPAT_XPMAC */
1120 default:
1121 return -ENOIOCTLCMD;
}
}
/*
* 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);
/*
* Sleeps until a vt is activated, or the task is interrupted. Returns
* 0 if activation, -EINTR if interrupted.
*/
1138 int vt_waitactive(int vt)
{
int retval;
DECLARE_WAITQUEUE(wait, current);
add_wait_queue(&vt_activate_queue, &wait);
1144 for (;;) {
1145 set_current_state(TASK_INTERRUPTIBLE);
retval = 0;
1147 if (vt == fg_console)
1148 break;
retval = -EINTR;
1150 if (signal_pending(current))
1151 break;
schedule();
}
remove_wait_queue(&vt_activate_queue, &wait);
current->state = TASK_RUNNING;
1156 return retval;
}
#define vt_wake_waitactive() wake_up(&vt_activate_queue)
1161 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) ;
}
/*
* Performs the back end of a vt switch
*/
1178 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())
*/
1197 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,
1206 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
*/
1225 if (old_vc_mode != vt_cons[new_console]->vc_mode)
{
1227 if (vt_cons[new_console]->vc_mode == KD_TEXT)
unblank_screen();
1229 else
do_blank_screen(1);
}
/*
* Wake anyone waiting for their VT to activate
*/
vt_wake_waitactive();
1237 return;
}
/*
* Performs the front-end of a vt switch
*/
1243 void change_console(unsigned int new_console)
{
1245 if ((new_console == fg_console) || (vt_dont_switch))
1246 return;
1247 if (!vc_cons_allocated(new_console))
1248 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.
*/
1265 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,
1274 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;
1282 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
*/
1304 if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
1305 return;
complete_change_console(new_console);
}