From: Roman Zippel This removes as far as possible unneccessary vc_cons lookups by using a pointer to the vc_data structure instead of the index. The hidden currcons argument in console_macros.h is temporarily replaced with a hidden vc pointer. Signed-off-by: Roman Zippel Signed-off-by: Andrew Morton --- 25-akpm/drivers/char/console_macros.h | 132 ++-- 25-akpm/drivers/char/consolemap.c | 97 +-- 25-akpm/drivers/char/keyboard.c | 6 25-akpm/drivers/char/selection.c | 6 25-akpm/drivers/char/sysrq.c | 5 25-akpm/drivers/char/tty_io.c | 4 25-akpm/drivers/char/vc_screen.c | 7 25-akpm/drivers/char/vt.c | 848 +++++++++++++++---------------- 25-akpm/drivers/char/vt_ioctl.c | 78 +- 25-akpm/drivers/video/console/dummycon.c | 2 25-akpm/drivers/video/console/fbcon.c | 46 - 25-akpm/drivers/video/console/mdacon.c | 7 25-akpm/drivers/video/console/promcon.c | 14 25-akpm/drivers/video/console/sticon.c | 2 25-akpm/drivers/video/console/vgacon.c | 10 25-akpm/fs/compat_ioctl.c | 10 25-akpm/include/linux/consolemap.h | 2 25-akpm/include/linux/vt_kern.h | 44 - 18 files changed, 646 insertions(+), 674 deletions(-) diff -puN drivers/char/console_macros.h~cleanup-vc-array-access drivers/char/console_macros.h --- 25/drivers/char/console_macros.h~cleanup-vc-array-access 2005-01-23 14:46:33.129282136 -0800 +++ 25-akpm/drivers/char/console_macros.h 2005-01-23 14:46:33.158277728 -0800 @@ -1,71 +1,71 @@ -#define cons_num (vc_cons[currcons].d->vc_num) -#define video_scan_lines (vc_cons[currcons].d->vc_scan_lines) -#define sw (vc_cons[currcons].d->vc_sw) -#define screenbuf (vc_cons[currcons].d->vc_screenbuf) -#define screenbuf_size (vc_cons[currcons].d->vc_screenbuf_size) -#define origin (vc_cons[currcons].d->vc_origin) -#define scr_top (vc_cons[currcons].d->vc_scr_top) -#define visible_origin (vc_cons[currcons].d->vc_visible_origin) -#define scr_end (vc_cons[currcons].d->vc_scr_end) -#define pos (vc_cons[currcons].d->vc_pos) -#define top (vc_cons[currcons].d->vc_top) -#define bottom (vc_cons[currcons].d->vc_bottom) -#define x (vc_cons[currcons].d->vc_x) -#define y (vc_cons[currcons].d->vc_y) -#define vc_state (vc_cons[currcons].d->vc_state) -#define npar (vc_cons[currcons].d->vc_npar) -#define par (vc_cons[currcons].d->vc_par) -#define ques (vc_cons[currcons].d->vc_ques) -#define attr (vc_cons[currcons].d->vc_attr) -#define saved_x (vc_cons[currcons].d->vc_saved_x) -#define saved_y (vc_cons[currcons].d->vc_saved_y) -#define translate (vc_cons[currcons].d->vc_translate) -#define G0_charset (vc_cons[currcons].d->vc_G0_charset) -#define G1_charset (vc_cons[currcons].d->vc_G1_charset) -#define saved_G0 (vc_cons[currcons].d->vc_saved_G0) -#define saved_G1 (vc_cons[currcons].d->vc_saved_G1) -#define utf (vc_cons[currcons].d->vc_utf) -#define utf_count (vc_cons[currcons].d->vc_utf_count) -#define utf_char (vc_cons[currcons].d->vc_utf_char) -#define video_erase_char (vc_cons[currcons].d->vc_video_erase_char) -#define disp_ctrl (vc_cons[currcons].d->vc_disp_ctrl) -#define toggle_meta (vc_cons[currcons].d->vc_toggle_meta) -#define decscnm (vc_cons[currcons].d->vc_decscnm) -#define decom (vc_cons[currcons].d->vc_decom) -#define decawm (vc_cons[currcons].d->vc_decawm) -#define deccm (vc_cons[currcons].d->vc_deccm) -#define decim (vc_cons[currcons].d->vc_decim) -#define deccolm (vc_cons[currcons].d->vc_deccolm) -#define need_wrap (vc_cons[currcons].d->vc_need_wrap) -#define kmalloced (vc_cons[currcons].d->vc_kmalloced) -#define report_mouse (vc_cons[currcons].d->vc_report_mouse) -#define color (vc_cons[currcons].d->vc_color) -#define s_color (vc_cons[currcons].d->vc_s_color) -#define def_color (vc_cons[currcons].d->vc_def_color) +#define cons_num (vc->vc_num) +#define video_scan_lines (vc->vc_scan_lines) +#define sw (vc->vc_sw) +#define screenbuf (vc->vc_screenbuf) +#define screenbuf_size (vc->vc_screenbuf_size) +#define origin (vc->vc_origin) +#define scr_top (vc->vc_scr_top) +#define visible_origin (vc->vc_visible_origin) +#define scr_end (vc->vc_scr_end) +#define pos (vc->vc_pos) +#define top (vc->vc_top) +#define bottom (vc->vc_bottom) +#define x (vc->vc_x) +#define y (vc->vc_y) +#define vc_state (vc->vc_state) +#define npar (vc->vc_npar) +#define par (vc->vc_par) +#define ques (vc->vc_ques) +#define attr (vc->vc_attr) +#define saved_x (vc->vc_saved_x) +#define saved_y (vc->vc_saved_y) +#define translate (vc->vc_translate) +#define G0_charset (vc->vc_G0_charset) +#define G1_charset (vc->vc_G1_charset) +#define saved_G0 (vc->vc_saved_G0) +#define saved_G1 (vc->vc_saved_G1) +#define utf (vc->vc_utf) +#define utf_count (vc->vc_utf_count) +#define utf_char (vc->vc_utf_char) +#define video_erase_char (vc->vc_video_erase_char) +#define disp_ctrl (vc->vc_disp_ctrl) +#define toggle_meta (vc->vc_toggle_meta) +#define decscnm (vc->vc_decscnm) +#define decom (vc->vc_decom) +#define decawm (vc->vc_decawm) +#define deccm (vc->vc_deccm) +#define decim (vc->vc_decim) +#define deccolm (vc->vc_deccolm) +#define need_wrap (vc->vc_need_wrap) +#define kmalloced (vc->vc_kmalloced) +#define report_mouse (vc->vc_report_mouse) +#define color (vc->vc_color) +#define s_color (vc->vc_s_color) +#define def_color (vc->vc_def_color) #define foreground (color & 0x0f) #define background (color & 0xf0) -#define charset (vc_cons[currcons].d->vc_charset) -#define s_charset (vc_cons[currcons].d->vc_s_charset) -#define intensity (vc_cons[currcons].d->vc_intensity) -#define underline (vc_cons[currcons].d->vc_underline) -#define blink (vc_cons[currcons].d->vc_blink) -#define reverse (vc_cons[currcons].d->vc_reverse) -#define s_intensity (vc_cons[currcons].d->vc_s_intensity) -#define s_underline (vc_cons[currcons].d->vc_s_underline) -#define s_blink (vc_cons[currcons].d->vc_s_blink) -#define s_reverse (vc_cons[currcons].d->vc_s_reverse) -#define ulcolor (vc_cons[currcons].d->vc_ulcolor) -#define halfcolor (vc_cons[currcons].d->vc_halfcolor) -#define tab_stop (vc_cons[currcons].d->vc_tab_stop) -#define palette (vc_cons[currcons].d->vc_palette) -#define bell_pitch (vc_cons[currcons].d->vc_bell_pitch) -#define bell_duration (vc_cons[currcons].d->vc_bell_duration) -#define cursor_type (vc_cons[currcons].d->vc_cursor_type) -#define display_fg (vc_cons[currcons].d->vc_display_fg) -#define complement_mask (vc_cons[currcons].d->vc_complement_mask) -#define s_complement_mask (vc_cons[currcons].d->vc_s_complement_mask) -#define hi_font_mask (vc_cons[currcons].d->vc_hi_font_mask) +#define charset (vc->vc_charset) +#define s_charset (vc->vc_s_charset) +#define intensity (vc->vc_intensity) +#define underline (vc->vc_underline) +#define blink (vc->vc_blink) +#define reverse (vc->vc_reverse) +#define s_intensity (vc->vc_s_intensity) +#define s_underline (vc->vc_s_underline) +#define s_blink (vc->vc_s_blink) +#define s_reverse (vc->vc_s_reverse) +#define ulcolor (vc->vc_ulcolor) +#define halfcolor (vc->vc_halfcolor) +#define tab_stop (vc->vc_tab_stop) +#define palette (vc->vc_palette) +#define bell_pitch (vc->vc_bell_pitch) +#define bell_duration (vc->vc_bell_duration) +#define cursor_type (vc->vc_cursor_type) +#define display_fg (vc->vc_display_fg) +#define complement_mask (vc->vc_complement_mask) +#define s_complement_mask (vc->vc_s_complement_mask) +#define hi_font_mask (vc->vc_hi_font_mask) -#define vcmode (vt_cons[currcons]->vc_mode) +#define vcmode (vt_cons[vc->vc_num]->vc_mode) #define structsize (sizeof(struct vc_data) + sizeof(struct vt_struct)) diff -puN drivers/char/consolemap.c~cleanup-vc-array-access drivers/char/consolemap.c --- 25/drivers/char/consolemap.c~cleanup-vc-array-access 2005-01-23 14:46:33.130281984 -0800 +++ 25-akpm/drivers/char/consolemap.c 2005-01-23 14:46:33.160277424 -0800 @@ -208,9 +208,9 @@ static void set_inverse_transl(struct vc } } -unsigned short *set_translate(int m,int currcons) +unsigned short *set_translate(int m, struct vc_data *vc) { - inv_translate[currcons] = m; + inv_translate[vc->vc_num] = m; return translations[m]; } @@ -362,15 +362,16 @@ static void con_release_unimap(struct un } } -void con_free_unimap(int con) +void con_free_unimap(struct vc_data *vc) { struct uni_pagedir *p; - struct vc_data *conp = vc_cons[con].d; - - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; - if (!p) return; - *conp->vc_uni_pagedir_loc = 0; - if (--p->refcount) return; + + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; + if (!p) + return; + *vc->vc_uni_pagedir_loc = 0; + if (--p->refcount) + return; con_release_unimap(p); kfree(p); } @@ -442,12 +443,11 @@ con_insert_unipair(struct uni_pagedir *p } /* ui is a leftover from using a hashtable, but might be used again */ -int con_clear_unimap(int con, struct unimapinit *ui) +int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui) { struct uni_pagedir *p, *q; - struct vc_data *conp = vc_cons[con].d; - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; if (p && p->readonly) return -EIO; if (!p || --p->refcount) { q = (struct uni_pagedir *)kmalloc(sizeof(*p), GFP_KERNEL); @@ -457,7 +457,7 @@ int con_clear_unimap(int con, struct uni } memset(q, 0, sizeof(*q)); q->refcount=1; - *conp->vc_uni_pagedir_loc = (unsigned long)q; + *vc->vc_uni_pagedir_loc = (unsigned long)q; } else { if (p == dflt) dflt = NULL; p->refcount++; @@ -467,14 +467,12 @@ int con_clear_unimap(int con, struct uni return 0; } -int -con_set_unimap(int con, ushort ct, struct unipair __user *list) +int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list) { int err = 0, err1, i; struct uni_pagedir *p, *q; - struct vc_data *conp = vc_cons[con].d; - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; if (p->readonly) return -EIO; if (!ct) return 0; @@ -483,10 +481,10 @@ con_set_unimap(int con, ushort ct, struc int j, k; u16 **p1, *p2, l; - err1 = con_clear_unimap(con, NULL); + err1 = con_clear_unimap(vc, NULL); if (err1) return err1; - q = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; for (i = 0, l = 0; i < 32; i++) if ((p1 = p->uni_pgdir[i])) for (j = 0; j < 32; j++) @@ -496,7 +494,7 @@ con_set_unimap(int con, ushort ct, struc err1 = con_insert_unipair(q, l, p2[k]); if (err1) { p->refcount++; - *conp->vc_uni_pagedir_loc = (unsigned long)p; + *vc->vc_uni_pagedir_loc = (unsigned long)p; con_release_unimap(q); kfree(q); return err1; @@ -515,11 +513,11 @@ con_set_unimap(int con, ushort ct, struc list++; } - if (con_unify_unimap(conp, p)) + if (con_unify_unimap(vc, p)) return err; for (i = 0; i <= 3; i++) - set_inverse_transl(conp, p, i); /* Update all inverse translations */ + set_inverse_transl(vc, p, i); /* Update all inverse translations */ return err; } @@ -529,20 +527,18 @@ con_set_unimap(int con, ushort ct, struc with. This routine is executed at sys_setup time, and when the PIO_FONTRESET ioctl is called. */ -int -con_set_default_unimap(int con) +int con_set_default_unimap(struct vc_data *vc) { int i, j, err = 0, err1; u16 *q; struct uni_pagedir *p; - struct vc_data *conp = vc_cons[con].d; - + if (dflt) { - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; if (p == dflt) return 0; dflt->refcount++; - *conp->vc_uni_pagedir_loc = (unsigned long)dflt; + *vc->vc_uni_pagedir_loc = (unsigned long)dflt; if (p && --p->refcount) { con_release_unimap(p); kfree(p); @@ -552,10 +548,10 @@ con_set_default_unimap(int con) /* The default font is always 256 characters */ - err = con_clear_unimap(con,NULL); + err = con_clear_unimap(vc, NULL); if (err) return err; - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; q = dfont_unitable; for (i = 0; i < 256; i++) @@ -565,47 +561,42 @@ con_set_default_unimap(int con) err = err1; } - if (con_unify_unimap(conp, p)) { - dflt = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + if (con_unify_unimap(vc, p)) { + dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; return err; } for (i = 0; i <= 3; i++) - set_inverse_transl(conp, p, i); /* Update all inverse translations */ + set_inverse_transl(vc, p, i); /* Update all inverse translations */ dflt = p; return err; } EXPORT_SYMBOL(con_set_default_unimap); -int -con_copy_unimap(int dstcon, int srccon) +int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc) { - struct vc_data *sconp = vc_cons[srccon].d; - struct vc_data *dconp = vc_cons[dstcon].d; struct uni_pagedir *q; - - if (!vc_cons_allocated(srccon) || !*sconp->vc_uni_pagedir_loc) + + if (!*src_vc->vc_uni_pagedir_loc) return -EINVAL; - if (*dconp->vc_uni_pagedir_loc == *sconp->vc_uni_pagedir_loc) + if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc) return 0; - con_free_unimap(dstcon); - q = (struct uni_pagedir *)*sconp->vc_uni_pagedir_loc; + con_free_unimap(dst_vc); + q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc; q->refcount++; - *dconp->vc_uni_pagedir_loc = (long)q; + *dst_vc->vc_uni_pagedir_loc = (long)q; return 0; } -int -con_get_unimap(int con, ushort ct, ushort __user *uct, struct unipair __user *list) +int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list) { int i, j, k, ect; u16 **p1, *p2; struct uni_pagedir *p; - struct vc_data *conp = vc_cons[con].d; ect = 0; - if (*conp->vc_uni_pagedir_loc) { - p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; + if (*vc->vc_uni_pagedir_loc) { + p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; for (i = 0; i < 32; i++) if ((p1 = p->uni_pgdir[i])) for (j = 0; j < 32; j++) @@ -625,12 +616,12 @@ con_get_unimap(int con, ushort ct, ushor return ((ect <= ct) ? 0 : -ENOMEM); } -void con_protect_unimap(int con, int rdonly) +void con_protect_unimap(struct vc_data *vc, int rdonly) { - struct uni_pagedir *p = (struct uni_pagedir *) - *vc_cons[con].d->vc_uni_pagedir_loc; + struct uni_pagedir *p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; - if (p) p->readonly = rdonly; + if (p) + p->readonly = rdonly; } int @@ -679,7 +670,7 @@ console_map_init(void) for (i = 0; i < MAX_NR_CONSOLES; i++) if (vc_cons_allocated(i) && !*vc_cons[i].d->vc_uni_pagedir_loc) - con_set_default_unimap(i); + con_set_default_unimap(vc_cons[i].d); } EXPORT_SYMBOL(con_copy_unimap); diff -puN drivers/char/keyboard.c~cleanup-vc-array-access drivers/char/keyboard.c --- 25/drivers/char/keyboard.c~cleanup-vc-array-access 2005-01-23 14:46:33.132281680 -0800 +++ 25-akpm/drivers/char/keyboard.c 2005-01-23 14:46:33.161277272 -0800 @@ -534,12 +534,12 @@ static void fn_send_intr(struct vc_data static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs) { - scrollfront(0); + scrollfront(vc, 0); } static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs) { - scrollback(0); + scrollback(vc, 0); } static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs) @@ -579,7 +579,7 @@ static void fn_SAK(struct vc_data *vc, s */ if (tty) do_SAK(tty); - reset_vc(fg_console); + reset_vc(vc); } static void fn_null(struct vc_data *vc, struct pt_regs *regs) diff -puN drivers/char/selection.c~cleanup-vc-array-access drivers/char/selection.c --- 25/drivers/char/selection.c~cleanup-vc-array-access 2005-01-23 14:46:33.133281528 -0800 +++ 25-akpm/drivers/char/selection.c 2005-01-23 14:46:33.161277272 -0800 @@ -43,15 +43,13 @@ static char *sel_buffer; from interrupt (via scrollback/front) */ /* set reverse video on characters s-e of console with selection. */ -inline static void -highlight(const int s, const int e) +static inline void highlight(const int s, const int e) { invert_screen(sel_cons, s, e-s+2, 1); } /* use complementary color to show the pointer */ -inline static void -highlight_pointer(const int where) +static inline void highlight_pointer(const int where) { complement_pos(sel_cons, where); } diff -puN drivers/char/sysrq.c~cleanup-vc-array-access drivers/char/sysrq.c --- 25/drivers/char/sysrq.c~cleanup-vc-array-access 2005-01-23 14:46:33.135281224 -0800 +++ 25-akpm/drivers/char/sysrq.c 2005-01-23 14:46:33.162277120 -0800 @@ -33,11 +33,10 @@ #include /* for fsync_bdev() */ #include #include +#include #include -extern void reset_vc(unsigned int); - /* Whether we react on sysrq keys or just ignore them */ int sysrq_enabled = 1; @@ -69,7 +68,7 @@ static void sysrq_handle_SAK(int key, st { if (tty) do_SAK(tty); - reset_vc(fg_console); + reset_vc(vc_cons[fg_console].d); } static struct sysrq_key_op sysrq_SAK_op = { .handler = sysrq_handle_SAK, diff -puN drivers/char/tty_io.c~cleanup-vc-array-access drivers/char/tty_io.c --- 25/drivers/char/tty_io.c~cleanup-vc-array-access 2005-01-23 14:46:33.136281072 -0800 +++ 25-akpm/drivers/char/tty_io.c 2005-01-23 14:46:33.164276816 -0800 @@ -1786,7 +1786,6 @@ retry_open: } #ifdef CONFIG_VT if (device == MKDEV(TTY_MAJOR,0)) { - extern int fg_console; extern struct tty_driver *console_driver; driver = console_driver; index = fg_console; @@ -2013,11 +2012,10 @@ static int tiocswinsz(struct tty_struct return 0; #ifdef CONFIG_VT if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) { - unsigned int currcons = tty->index; int rc; acquire_console_sem(); - rc = vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row); + rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row); release_console_sem(); if (rc) return -ENXIO; diff -puN drivers/char/vc_screen.c~cleanup-vc-array-access drivers/char/vc_screen.c --- 25/drivers/char/vc_screen.c~cleanup-vc-array-access 2005-01-23 14:46:33.138280768 -0800 +++ 25-akpm/drivers/char/vc_screen.c 2005-01-23 14:46:33.165276664 -0800 @@ -52,14 +52,17 @@ vcs_size(struct inode *inode) int size; int minor = iminor(inode); int currcons = minor & 127; + struct vc_data *vc; + if (currcons == 0) currcons = fg_console; else currcons--; if (!vc_cons_allocated(currcons)) return -ENXIO; + vc = vc_cons[currcons].d; - size = vc_cons[currcons].d->vc_rows * vc_cons[currcons].d->vc_cols; + size = vc->vc_rows * vc->vc_cols; if (minor & 128) size = 2*size + HEADER_SIZE; @@ -442,7 +445,7 @@ vcs_write(struct file *file, const char buf += orig_count; pos += orig_count; if (org0) - update_region(currcons, (unsigned long)(org0), org-org0); + update_region(vc, (unsigned long)(org0), org-org0); } *ppos += written; ret = written; diff -puN drivers/char/vt.c~cleanup-vc-array-access drivers/char/vt.c --- 25/drivers/char/vt.c~cleanup-vc-array-access 2005-01-23 14:46:33.139280616 -0800 +++ 25-akpm/drivers/char/vt.c 2005-01-23 14:46:33.177274840 -0800 @@ -135,11 +135,11 @@ static const struct consw *con_driver_ma #endif static int con_open(struct tty_struct *, struct file *); -static void vc_init(unsigned int console, unsigned int rows, +static void vc_init(struct vc_data *vc, unsigned int rows, unsigned int cols, int do_clear); static void gotoxy(struct vc_data *vc, int new_x, int new_y); -static void save_cur(int currcons); -static void reset_terminal(int currcons, int do_clear); +static void save_cur(struct vc_data *vc); +static void reset_terminal(struct vc_data *vc, int do_clear); static void con_flush_chars(struct tty_struct *tty); static void set_vesa_blanking(char __user *p); static void set_cursor(struct vc_data *vc); @@ -214,17 +214,10 @@ enum { * Low-Level Functions */ -#define IS_FG (currcons == fg_console) -#define IS_FG_VC(vc) (vc == vc_cons[fg_console].d) - -#define IS_VISIBLE CON_IS_VISIBLE(vc_cons[currcons].d) - #ifdef VT_BUF_VRAM_ONLY -#define DO_UPDATE 0 -#define DO_UPDATE_VC(vc) 0 +#define DO_UPDATE(vc) 0 #else -#define DO_UPDATE IS_VISIBLE -#define DO_UPDATE_VC(vc) CON_IS_VISIBLE(vc) +#define DO_UPDATE(vc) CON_IS_VISIBLE(vc) #endif static int pm_con_request(struct pm_dev *dev, pm_request_t rqst, void *data); @@ -254,38 +247,37 @@ void schedule_console_callback(void) schedule_work(&console_work); } -static void scrup(int currcons, unsigned int t, unsigned int b, int nr) +static void scrup(struct vc_data *vc, unsigned int t, unsigned int b, int nr) { unsigned short *d, *s; if (t+nr >= b) nr = b - t - 1; - if (b > vc_cons[currcons].d->vc_rows || t >= b || nr < 1) + if (b > vc->vc_rows || t >= b || nr < 1) return; - if (IS_VISIBLE && sw->con_scroll(vc_cons[currcons].d, t, b, SM_UP, nr)) + if (CON_IS_VISIBLE(vc) && sw->con_scroll(vc, t, b, SM_UP, nr)) return; - d = (unsigned short *) (origin+vc_cons[currcons].d->vc_size_row*t); - s = (unsigned short *) (origin+vc_cons[currcons].d->vc_size_row*(t+nr)); - scr_memmovew(d, s, (b-t-nr) * vc_cons[currcons].d->vc_size_row); - scr_memsetw(d + (b-t-nr) * vc_cons[currcons].d->vc_cols, video_erase_char, - vc_cons[currcons].d->vc_size_row * nr); + d = (unsigned short *)(origin + vc->vc_size_row * t); + s = (unsigned short *)(origin + vc->vc_size_row * (t + nr)); + scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row); + scr_memsetw(d + (b - t - nr) * vc->vc_cols, video_erase_char, + vc->vc_size_row * nr); } -static void -scrdown(int currcons, unsigned int t, unsigned int b, int nr) +static void scrdown(struct vc_data *vc, unsigned int t, unsigned int b, int nr) { unsigned short *s; unsigned int step; if (t+nr >= b) nr = b - t - 1; - if (b > vc_cons[currcons].d->vc_rows || t >= b || nr < 1) + if (b > vc->vc_rows || t >= b || nr < 1) return; - if (IS_VISIBLE && sw->con_scroll(vc_cons[currcons].d, t, b, SM_DOWN, nr)) + if (CON_IS_VISIBLE(vc) && sw->con_scroll(vc, t, b, SM_DOWN, nr)) return; - s = (unsigned short *) (origin+vc_cons[currcons].d->vc_size_row*t); - step = vc_cons[currcons].d->vc_cols * nr; - scr_memmovew(s + step, s, (b-t-nr)*vc_cons[currcons].d->vc_size_row); + s = (unsigned short *)(origin + vc->vc_size_row * t); + step = vc->vc_cols * nr; + scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row); scr_memsetw(s, video_erase_char, 2*step); } @@ -335,23 +327,23 @@ static void do_update_region(struct vc_d #endif } -void update_region(int currcons, unsigned long start, int count) +void update_region(struct vc_data *vc, unsigned long start, int count) { WARN_CONSOLE_UNLOCKED(); - if (DO_UPDATE) { - hide_cursor(vc_cons[currcons].d); - do_update_region(vc_cons[currcons].d, start, count); - set_cursor(vc_cons[currcons].d); + if (DO_UPDATE(vc)) { + hide_cursor(vc); + do_update_region(vc, start, count); + set_cursor(vc); } } /* Structure of attributes is hardware-dependent */ -static u8 build_attr(int currcons, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse) +static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse) { if (sw->con_build_attr) - return sw->con_build_attr(vc_cons[currcons].d, _color, _intensity, _blink, _underline, _reverse); + return sw->con_build_attr(vc, _color, _intensity, _blink, _underline, _reverse); #ifndef VT_BUF_VRAM_ONLY /* @@ -366,7 +358,7 @@ static u8 build_attr(int currcons, u8 _c */ { u8 a = color; - if (!vc_cons[currcons].d->vc_can_do_color) + if (!vc->vc_can_do_color) return _intensity | (_underline ? 4 : 0) | (_reverse ? 8 : 0) | @@ -390,10 +382,10 @@ static u8 build_attr(int currcons, u8 _c #endif } -static void update_attr(int currcons) +static void update_attr(struct vc_data *vc) { - attr = build_attr(currcons, color, intensity, blink, underline, reverse ^ decscnm); - video_erase_char = (build_attr(currcons, color, 1, blink, 0, decscnm) << 8) | ' '; + attr = build_attr(vc, color, intensity, blink, underline, reverse ^ decscnm); + video_erase_char = (build_attr(vc, color, 1, blink, 0, decscnm) << 8) | ' '; } /* Note: inverting the screen twice should revert to the original state */ @@ -437,7 +429,7 @@ void invert_screen(struct vc_data *vc, i } } #endif - if (DO_UPDATE_VC(vc)) + if (DO_UPDATE(vc)) do_update_region(vc, (unsigned long) p, count); } @@ -452,7 +444,7 @@ void complement_pos(struct vc_data *vc, if (p) { scr_writew(old, p); - if (DO_UPDATE_VC(vc)) + if (DO_UPDATE(vc)) vc->vc_sw->con_putc(vc, old, oldy, oldx); } if (offset == -1) @@ -463,7 +455,7 @@ void complement_pos(struct vc_data *vc, old = scr_readw(p); new = old ^ vc->vc_complement_mask; scr_writew(new, p); - if (DO_UPDATE_VC(vc)) { + if (DO_UPDATE(vc)) { oldx = (offset >> 1) % vc->vc_cols; oldy = (offset >> 1) / vc->vc_cols; vc->vc_sw->con_putc(vc, new, oldy, oldx); @@ -471,47 +463,45 @@ void complement_pos(struct vc_data *vc, } } -static void insert_char(int currcons, unsigned int nr) +static void insert_char(struct vc_data *vc, unsigned int nr) { unsigned short *p, *q = (unsigned short *) pos; - p = q + vc_cons[currcons].d->vc_cols - nr - x; + p = q + vc->vc_cols - nr - x; while (--p >= q) scr_writew(scr_readw(p), p + nr); scr_memsetw(q, video_erase_char, nr*2); need_wrap = 0; - if (DO_UPDATE) { + if (DO_UPDATE(vc)) { unsigned short oldattr = attr; - sw->con_bmove(vc_cons[currcons].d,y,x,y,x+nr,1, - vc_cons[currcons].d->vc_cols-x-nr); + sw->con_bmove(vc, y, x, y, x + nr, 1, + vc->vc_cols - x - nr); attr = video_erase_char >> 8; while (nr--) - sw->con_putc(vc_cons[currcons].d, - video_erase_char,y,x+nr); + sw->con_putc(vc, video_erase_char, y, x + nr); attr = oldattr; } } -static void delete_char(int currcons, unsigned int nr) +static void delete_char(struct vc_data *vc, unsigned int nr) { unsigned int i = x; unsigned short *p = (unsigned short *) pos; - while (++i <= vc_cons[currcons].d->vc_cols - nr) { + while (++i <= vc->vc_cols - nr) { scr_writew(scr_readw(p+nr), p); p++; } scr_memsetw(p, video_erase_char, nr*2); need_wrap = 0; - if (DO_UPDATE) { + if (DO_UPDATE(vc)) { unsigned short oldattr = attr; - sw->con_bmove(vc_cons[currcons].d, y, x+nr, y, x, 1, - vc_cons[currcons].d->vc_cols-x-nr); + sw->con_bmove(vc, y, x + nr, y, x, 1, + vc->vc_cols - x - nr); attr = video_erase_char >> 8; while (nr--) - sw->con_putc(vc_cons[currcons].d, - video_erase_char, y, - vc_cons[currcons].d->vc_cols-1-nr); + sw->con_putc(vc, video_erase_char, y, + vc->vc_cols - 1 - nr); attr = oldattr; } } @@ -531,7 +521,7 @@ static void add_softcursor(struct vc_dat if ((type & 0x20) && ((softcursor_original & 0x7000) == (i & 0x7000))) i ^= 0x7000; if ((type & 0x40) && ((i & 0x700) == ((i & 0x7000) >> 4))) i ^= 0x0700; scr_writew(i, (u16 *) vc->vc_pos); - if (DO_UPDATE_VC(vc)) + if (DO_UPDATE(vc)) vc->vc_sw->con_putc(vc, i, vc->vc_y, vc->vc_x); } @@ -539,7 +529,7 @@ static void hide_softcursor(struct vc_da { if (softcursor_original != -1) { scr_writew(softcursor_original, (u16 *)vc->vc_pos); - if (DO_UPDATE_VC(vc)) + if (DO_UPDATE(vc)) vc->vc_sw->con_putc(vc, softcursor_original, vc->vc_y, vc->vc_x); softcursor_original = -1; @@ -556,7 +546,7 @@ static void hide_cursor(struct vc_data * static void set_cursor(struct vc_data *vc) { - if (!IS_FG_VC(vc) || console_blanked || + if (!vc->vc_num != fg_console || console_blanked || vc->vc_vt->vc_mode == KD_GRAPHICS) return; if (vc->vc_deccm) { @@ -569,32 +559,32 @@ static void set_cursor(struct vc_data *v hide_cursor(vc); } -static void set_origin(int currcons) +static void set_origin(struct vc_data *vc) { WARN_CONSOLE_UNLOCKED(); - if (!IS_VISIBLE || + if (!CON_IS_VISIBLE(vc) || !sw->con_set_origin || - !sw->con_set_origin(vc_cons[currcons].d)) + !sw->con_set_origin(vc)) origin = (unsigned long) screenbuf; visible_origin = origin; scr_end = origin + screenbuf_size; - pos = origin + vc_cons[currcons].d->vc_size_row*y + 2*x; + pos = origin + vc->vc_size_row * y + 2 * x; } -static inline void save_screen(int currcons) +static inline void save_screen(struct vc_data *vc) { WARN_CONSOLE_UNLOCKED(); if (sw->con_save_screen) - sw->con_save_screen(vc_cons[currcons].d); + sw->con_save_screen(vc); } /* * Redrawing of screen */ -static void clear_buffer_attributes(int currcons) +static void clear_buffer_attributes(struct vc_data *vc) { unsigned short *p = (unsigned short *) origin; int count = screenbuf_size/2; @@ -605,62 +595,57 @@ static void clear_buffer_attributes(int } } -void redraw_screen(int new_console, int is_switch) +void redraw_screen(struct vc_data *vc, int is_switch) { - int redraw = 1; - int currcons, old_console; + int redraw = 0; WARN_CONSOLE_UNLOCKED(); - if (!vc_cons_allocated(new_console)) { + if (!vc) { /* strange ... */ /* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */ return; } if (is_switch) { - currcons = fg_console; - hide_cursor(vc_cons[currcons].d); - 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; + struct vc_data *old_vc = vc_cons[fg_console].d; + if (old_vc == vc) + return; + if (!CON_IS_VISIBLE(vc)) + redraw = 1; + *vc->vc_display_fg = vc; + fg_console = vc->vc_num; + hide_cursor(old_vc); + if (!CON_IS_VISIBLE(old_vc)) { + save_screen(old_vc); + set_origin(old_vc); } } else { - currcons = new_console; - hide_cursor(vc_cons[currcons].d); + hide_cursor(vc); + redraw = 1; } if (redraw) { int update; - int old_was_color = vc_cons[currcons].d->vc_can_do_color; + int old_was_color = vc->vc_can_do_color; - set_origin(currcons); - update = sw->con_switch(vc_cons[currcons].d); - set_palette(currcons); + set_origin(vc); + update = sw->con_switch(vc); + set_palette(vc); /* * If console changed from mono<->color, the best we can do * is to clear the buffer attributes. As it currently stands, * rebuilding new attributes from the old buffer is not doable * without overly complex code. */ - if (old_was_color != vc_cons[currcons].d->vc_can_do_color) { - update_attr(currcons); - clear_buffer_attributes(currcons); + if (old_was_color != vc->vc_can_do_color) { + update_attr(vc); + clear_buffer_attributes(vc); } if (update && vcmode != KD_GRAPHICS) - do_update_region(vc_cons[currcons].d, origin, screenbuf_size/2); + do_update_region(vc, origin, screenbuf_size / 2); } - set_cursor(vc_cons[currcons].d); + set_cursor(vc); if (is_switch) { set_leds(); compute_shiftstate(); @@ -676,31 +661,30 @@ int vc_cons_allocated(unsigned int i) return (i < MAX_NR_CONSOLES && vc_cons[i].d); } -static void visual_init(int currcons, int init) +static void visual_init(struct vc_data *vc, int num, int init) { - /* ++Geert: sw->con_init determines console size */ - if (sw) - module_put(sw->owner); - sw = conswitchp; + /* ++Geert: sw->con_init determines console size */ + if (sw) + module_put(sw->owner); + sw = conswitchp; #ifndef VT_SINGLE_DRIVER - if (con_driver_map[currcons]) - sw = con_driver_map[currcons]; + if (con_driver_map[num]) + sw = con_driver_map[num]; #endif - __module_get(sw->owner); - cons_num = currcons; - display_fg = &master_display_fg; - vc_cons[currcons].d->vc_uni_pagedir_loc = &vc_cons[currcons].d->vc_uni_pagedir; - vc_cons[currcons].d->vc_uni_pagedir = 0; - hi_font_mask = 0; - complement_mask = 0; - vc_cons[currcons].d->vc_can_do_color = 0; - sw->con_init(vc_cons[currcons].d, init); - if (!complement_mask) - complement_mask = - vc_cons[currcons].d->vc_can_do_color ? 0x7700 : 0x0800; - s_complement_mask = complement_mask; - vc_cons[currcons].d->vc_size_row = vc_cons[currcons].d->vc_cols<<1; - screenbuf_size = vc_cons[currcons].d->vc_rows * vc_cons[currcons].d->vc_size_row; + __module_get(sw->owner); + vc->vc_num = num; + display_fg = &master_display_fg; + vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir; + vc->vc_uni_pagedir = 0; + hi_font_mask = 0; + complement_mask = 0; + vc->vc_can_do_color = 0; + sw->con_init(vc, init); + if (!complement_mask) + complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800; + s_complement_mask = complement_mask; + vc->vc_size_row = vc->vc_cols << 1; + screenbuf_size = vc->vc_rows * vc->vc_size_row; } int vc_allocate(unsigned int currcons) /* return 0 on success */ @@ -710,6 +694,7 @@ int vc_allocate(unsigned int currcons) / if (currcons >= MAX_NR_CONSOLES) return -ENXIO; if (!vc_cons[currcons].d) { + struct vc_data *vc; long p, q; /* prevent users from taking too much memory */ @@ -726,12 +711,12 @@ int vc_allocate(unsigned int currcons) / if (!p) return -ENOMEM; memset((void *)p, 0, structsize); - vc_cons[currcons].d = (struct vc_data *)p; + vc_cons[currcons].d = vc = (struct vc_data *)p; vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data)); vc_cons[currcons].d->vc_vt = vt_cons[currcons]; - visual_init(currcons, 1); - if (!*vc_cons[currcons].d->vc_uni_pagedir_loc) - con_set_default_unimap(currcons); + visual_init(vc, currcons, 1); + if (!*vc->vc_uni_pagedir_loc) + con_set_default_unimap(vc); q = (long)kmalloc(screenbuf_size, GFP_KERNEL); if (!q) { kfree((char *) p); @@ -741,7 +726,7 @@ int vc_allocate(unsigned int currcons) / } screenbuf = (unsigned short *) q; kmalloced = 1; - vc_init(currcons, vc_cons[currcons].d->vc_rows, vc_cons[currcons].d->vc_cols, 1); + vc_init(vc, vc->vc_rows, vc->vc_cols, 1); if (!pm_con) { pm_con = pm_register(PM_SYS_DEV, @@ -752,13 +737,13 @@ int vc_allocate(unsigned int currcons) / return 0; } -inline int resize_screen(int currcons, int width, int height) +inline int resize_screen(struct vc_data *vc, int width, int height) { /* Resizes the resolution of the display adapater */ int err = 0; if (vcmode != KD_GRAPHICS && sw->con_resize) - err = sw->con_resize(vc_cons[currcons].d, width, height); + err = sw->con_resize(vc, width, height); return err; } @@ -769,7 +754,7 @@ inline int resize_screen(int currcons, i */ #define VC_RESIZE_MAXCOL (32767) #define VC_RESIZE_MAXROW (32767) -int vc_resize(int currcons, unsigned int cols, unsigned int lines) +int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines) { unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0; unsigned int old_cols, old_rows, old_row_size, old_screen_size; @@ -778,38 +763,38 @@ int vc_resize(int currcons, unsigned int WARN_CONSOLE_UNLOCKED(); - if (!vc_cons_allocated(currcons)) + if (!vc) return -ENXIO; if (cols > VC_RESIZE_MAXCOL || lines > VC_RESIZE_MAXROW) return -EINVAL; - new_cols = (cols ? cols : vc_cons[currcons].d->vc_cols); - new_rows = (lines ? lines : vc_cons[currcons].d->vc_rows); + new_cols = (cols ? cols : vc->vc_cols); + new_rows = (lines ? lines : vc->vc_rows); new_row_size = new_cols << 1; new_screen_size = new_row_size * new_rows; - if (new_cols == vc_cons[currcons].d->vc_cols && new_rows == vc_cons[currcons].d->vc_rows) + if (new_cols == vc->vc_cols && new_rows == vc->vc_rows) return 0; newscreen = (unsigned short *) kmalloc(new_screen_size, GFP_USER); if (!newscreen) return -ENOMEM; - old_rows = vc_cons[currcons].d->vc_rows; - old_cols = vc_cons[currcons].d->vc_cols; - old_row_size = vc_cons[currcons].d->vc_size_row; + old_rows = vc->vc_rows; + old_cols = vc->vc_cols; + old_row_size = vc->vc_size_row; old_screen_size = screenbuf_size; - err = resize_screen(currcons, new_cols, new_rows); + err = resize_screen(vc, new_cols, new_rows); if (err) { kfree(newscreen); return err; } - vc_cons[currcons].d->vc_rows = new_rows; - vc_cons[currcons].d->vc_cols = new_cols; - vc_cons[currcons].d->vc_size_row = new_row_size; + vc->vc_rows = new_rows; + vc->vc_cols = new_cols; + vc->vc_size_row = new_row_size; screenbuf_size = new_screen_size; rlth = min(old_row_size, new_row_size); @@ -820,7 +805,7 @@ int vc_resize(int currcons, unsigned int if (new_rows < old_rows) old_origin += (old_rows - new_rows) * old_row_size; - update_attr(currcons); + update_attr(vc); while (old_origin < scr_end) { scr_memcpyw((unsigned short *) new_origin, (unsigned short *) old_origin, rlth); @@ -836,29 +821,29 @@ int vc_resize(int currcons, unsigned int screenbuf = newscreen; kmalloced = 1; screenbuf_size = new_screen_size; - set_origin(currcons); + set_origin(vc); /* do part of a reset_terminal() */ top = 0; - bottom = vc_cons[currcons].d->vc_rows; - gotoxy(vc_cons[currcons].d, x, y); - save_cur(currcons); + bottom = vc->vc_rows; + gotoxy(vc, x, y); + save_cur(vc); - if (vc_cons[currcons].d->vc_tty) { - struct winsize ws, *cws = &vc_cons[currcons].d->vc_tty->winsize; + if (vc->vc_tty) { + struct winsize ws, *cws = &vc->vc_tty->winsize; memset(&ws, 0, sizeof(ws)); - ws.ws_row = vc_cons[currcons].d->vc_rows; - ws.ws_col = vc_cons[currcons].d->vc_cols; + ws.ws_row = vc->vc_rows; + ws.ws_col = vc->vc_cols; ws.ws_ypixel = video_scan_lines; if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) && - vc_cons[currcons].d->vc_tty->pgrp > 0) - kill_pg(vc_cons[currcons].d->vc_tty->pgrp, SIGWINCH, 1); + vc->vc_tty->pgrp > 0) + kill_pg(vc->vc_tty->pgrp, SIGWINCH, 1); *cws = ws; } - if (IS_VISIBLE) - update_screen(currcons); + if (CON_IS_VISIBLE(vc)) + update_screen(vc); return err; } @@ -868,12 +853,13 @@ void vc_disallocate(unsigned int currcon WARN_CONSOLE_UNLOCKED(); if (vc_cons_allocated(currcons)) { - sw->con_deinit(vc_cons[currcons].d); - if (kmalloced) - kfree(screenbuf); - if (currcons >= MIN_NR_CONSOLES) - kfree(vc_cons[currcons].d); - vc_cons[currcons].d = NULL; + struct vc_data *vc = vc_cons[currcons].d; + sw->con_deinit(vc); + if (kmalloced) + kfree(screenbuf); + if (currcons >= MIN_NR_CONSOLES) + kfree(vc); + vc_cons[currcons].d = NULL; } } @@ -881,9 +867,9 @@ void vc_disallocate(unsigned int currcon * VT102 emulator */ -#define set_kbd(x) set_vc_kbd_mode(kbd_table+currcons,x) -#define clr_kbd(x) clr_vc_kbd_mode(kbd_table+currcons,x) -#define is_kbd(x) vc_kbd_mode(kbd_table+currcons,x) +#define set_kbd(vc, x) set_vc_kbd_mode(kbd_table + vc->vc_num, x) +#define clr_kbd(vc, x) clr_vc_kbd_mode(kbd_table + vc->vc_num, x) +#define is_kbd(vc, x) vc_kbd_mode(kbd_table + vc->vc_num, x) #define decarm VC_REPEAT #define decckm VC_CKMODE @@ -943,64 +929,60 @@ static void gotoxy(struct vc_data *vc, i } /* for absolute user moves, when decom is set */ -static void gotoxay(int currcons, int new_x, int new_y) +static void gotoxay(struct vc_data *vc, int new_x, int new_y) { - gotoxy(vc_cons[currcons].d, new_x, decom ? (top+new_y) : new_y); + gotoxy(vc, new_x, decom ? (top+new_y) : new_y); } -void scrollback(int lines) +void scrollback(struct vc_data *vc, int lines) { - int currcons = fg_console; - if (!lines) - lines = vc_cons[currcons].d->vc_rows/2; + lines = vc->vc_rows / 2; scrolldelta(-lines); } -void scrollfront(int lines) +void scrollfront(struct vc_data *vc, int lines) { - int currcons = fg_console; - if (!lines) - lines = vc_cons[currcons].d->vc_rows/2; + lines = vc->vc_rows / 2; scrolldelta(lines); } -static void lf(int currcons) +static void lf(struct vc_data *vc) { /* don't scroll if above bottom of scrolling region, or * if below scrolling region */ if (y+1 == bottom) - scrup(currcons,top,bottom,1); - else if (y < vc_cons[currcons].d->vc_rows-1) { + scrup(vc, top, bottom, 1); + else if (y < vc->vc_rows - 1) { y++; - pos += vc_cons[currcons].d->vc_size_row; + pos += vc->vc_size_row; } need_wrap = 0; } -static void ri(int currcons) +static void ri(struct vc_data *vc) { /* don't scroll if below top of scrolling region, or * if above scrolling region */ if (y == top) - scrdown(currcons,top,bottom,1); + scrdown(vc, top, bottom, 1); else if (y > 0) { y--; - pos -= vc_cons[currcons].d->vc_size_row; + pos -= vc->vc_size_row; } need_wrap = 0; } -static inline void cr(int currcons) +static inline void cr(struct vc_data *vc) { pos -= x<<1; need_wrap = x = 0; } -static inline void bs(int currcons) +static inline void bs(struct vc_data *vc) { if (x) { pos -= 2; @@ -1009,12 +991,12 @@ static inline void bs(int currcons) } } -static inline void del(int currcons) +static inline void del(struct vc_data *vc) { /* ignored */ } -static void csi_J(int currcons, int vpar) +static void csi_J(struct vc_data *vc, int vpar) { unsigned int count; unsigned short * start; @@ -1023,33 +1005,33 @@ static void csi_J(int currcons, int vpar case 0: /* erase from cursor to end of display */ count = (scr_end-pos)>>1; start = (unsigned short *) pos; - if (DO_UPDATE) { + if (DO_UPDATE(vc)) { /* do in two stages */ - sw->con_clear(vc_cons[currcons].d, y, x, 1, - vc_cons[currcons].d->vc_cols-x); - sw->con_clear(vc_cons[currcons].d, y+1, 0, - vc_cons[currcons].d->vc_rows-y-1, - vc_cons[currcons].d->vc_cols); + sw->con_clear(vc, y, x, 1, + vc->vc_cols - x); + sw->con_clear(vc, y + 1, 0, + vc->vc_rows - y - 1, + vc->vc_cols); } break; case 1: /* erase from start to cursor */ count = ((pos-origin)>>1)+1; start = (unsigned short *) origin; - if (DO_UPDATE) { + if (DO_UPDATE(vc)) { /* do in two stages */ - sw->con_clear(vc_cons[currcons].d, 0, 0, y, - vc_cons[currcons].d->vc_cols); - sw->con_clear(vc_cons[currcons].d, y, 0, 1, + sw->con_clear(vc, 0, 0, y, + vc->vc_cols); + sw->con_clear(vc, y, 0, 1, x + 1); } break; case 2: /* erase whole display */ - count = vc_cons[currcons].d->vc_cols * vc_cons[currcons].d->vc_rows; + count = vc->vc_cols * vc->vc_rows; start = (unsigned short *) origin; - if (DO_UPDATE) - sw->con_clear(vc_cons[currcons].d, 0, 0, - vc_cons[currcons].d->vc_rows, - vc_cons[currcons].d->vc_cols); + if (DO_UPDATE(vc)) + sw->con_clear(vc, 0, 0, + vc->vc_rows, + vc->vc_cols); break; default: return; @@ -1058,32 +1040,32 @@ static void csi_J(int currcons, int vpar need_wrap = 0; } -static void csi_K(int currcons, int vpar) +static void csi_K(struct vc_data *vc, int vpar) { unsigned int count; unsigned short * start; switch (vpar) { case 0: /* erase from cursor to end of line */ - count = vc_cons[currcons].d->vc_cols-x; + count = vc->vc_cols - x; start = (unsigned short *) pos; - if (DO_UPDATE) - sw->con_clear(vc_cons[currcons].d, y, x, 1, - vc_cons[currcons].d->vc_cols-x); + if (DO_UPDATE(vc)) + sw->con_clear(vc, y, x, 1, + vc->vc_cols - x); break; case 1: /* erase from start of line to cursor */ start = (unsigned short *) (pos - (x<<1)); count = x+1; - if (DO_UPDATE) - sw->con_clear(vc_cons[currcons].d, y, 0, 1, + if (DO_UPDATE(vc)) + sw->con_clear(vc, y, 0, 1, x + 1); break; case 2: /* erase whole line */ start = (unsigned short *) (pos - (x<<1)); - count = vc_cons[currcons].d->vc_cols; - if (DO_UPDATE) - sw->con_clear(vc_cons[currcons].d, y, 0, 1, - vc_cons[currcons].d->vc_cols); + count = vc->vc_cols; + if (DO_UPDATE(vc)) + sw->con_clear(vc, y, 0, 1, + vc->vc_cols); break; default: return; @@ -1092,21 +1074,21 @@ static void csi_K(int currcons, int vpar need_wrap = 0; } -static void csi_X(int currcons, int vpar) /* erase the following vpar positions */ +static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar positions */ { /* not vt100? */ int count; if (!vpar) vpar++; - count = (vpar > vc_cons[currcons].d->vc_cols-x) ? (vc_cons[currcons].d->vc_cols-x) : vpar; + count = (vpar > vc->vc_cols - x) ? (vc->vc_cols - x) : vpar; scr_memsetw((unsigned short *) pos, video_erase_char, 2 * count); - if (DO_UPDATE) - sw->con_clear(vc_cons[currcons].d, y, x, 1, count); + if (DO_UPDATE(vc)) + sw->con_clear(vc, y, x, 1, count); need_wrap = 0; } -static void default_attr(int currcons) +static void default_attr(struct vc_data *vc) { intensity = 1; underline = 0; @@ -1116,14 +1098,14 @@ static void default_attr(int currcons) } /* console_sem is held */ -static void csi_m(int currcons) +static void csi_m(struct vc_data *vc) { int i; for (i=0;i<=npar;i++) switch (par[i]) { case 0: /* all attributes off */ - default_attr(currcons); + default_attr(vc); break; case 1: intensity = 2; @@ -1147,7 +1129,7 @@ static void csi_m(int currcons) */ translate = set_translate(charset == 0 ? G0_charset - : G1_charset,currcons); + : G1_charset, vc); disp_ctrl = 0; toggle_meta = 0; break; @@ -1155,7 +1137,7 @@ static void csi_m(int currcons) * Select first alternate font, lets * chars < 32 be displayed as ROM chars. */ - translate = set_translate(IBMPC_MAP,currcons); + translate = set_translate(IBMPC_MAP, vc); disp_ctrl = 1; toggle_meta = 0; break; @@ -1163,7 +1145,7 @@ static void csi_m(int currcons) * Select second alternate font, toggle * high bit before displaying as ROM char. */ - translate = set_translate(IBMPC_MAP,currcons); + translate = set_translate(IBMPC_MAP, vc); disp_ctrl = 1; toggle_meta = 1; break; @@ -1208,7 +1190,7 @@ static void csi_m(int currcons) | foreground; break; } - update_attr(currcons); + update_attr(vc); } static void respond_string(const char *p, struct tty_struct *tty) @@ -1220,7 +1202,7 @@ static void respond_string(const char *p con_schedule_flip(tty); } -static void cursor_report(int currcons, struct tty_struct *tty) +static void cursor_report(struct vc_data *vc, struct tty_struct *tty) { char buf[40]; @@ -1250,13 +1232,13 @@ void mouse_report(struct tty_struct *tty /* invoked via ioctl(TIOCLINUX) and through set_selection */ int mouse_reporting(void) { - int currcons = fg_console; + struct vc_data *vc = vc_cons[fg_console].d; return report_mouse; } /* console_sem is held */ -static void set_mode(int currcons, int on_off) +static void set_mode(struct vc_data *vc, int on_off) { int i; @@ -1264,14 +1246,14 @@ static void set_mode(int currcons, int o if (ques) switch(par[i]) { /* DEC private modes set/reset */ case 1: /* Cursor keys send ^[Ox/^[[x */ if (on_off) - set_kbd(decckm); + set_kbd(vc, decckm); else - clr_kbd(decckm); + clr_kbd(vc, decckm); break; case 3: /* 80/132 mode switch unimplemented */ deccolm = on_off; #if 0 - (void) vc_resize(deccolm ? 132 : 80, vc_cons[currcons].d->vc_rows); + vc_resize(deccolm ? 132 : 80, vc->vc_rows); /* this alone does not suffice; some user mode utility has to change the hardware regs */ #endif @@ -1279,22 +1261,22 @@ static void set_mode(int currcons, int o case 5: /* Inverted screen on/off */ if (decscnm != on_off) { decscnm = on_off; - invert_screen(vc_cons[currcons].d, 0, screenbuf_size, 0); - update_attr(currcons); + invert_screen(vc, 0, screenbuf_size, 0); + update_attr(vc); } break; case 6: /* Origin relative/absolute */ decom = on_off; - gotoxay(currcons,0,0); + gotoxay(vc, 0, 0); break; case 7: /* Autowrap on/off */ decawm = on_off; break; case 8: /* Autorepeat on/off */ if (on_off) - set_kbd(decarm); + set_kbd(vc, decarm); else - clr_kbd(decarm); + clr_kbd(vc, decarm); break; case 9: report_mouse = on_off ? 1 : 0; @@ -1314,39 +1296,39 @@ static void set_mode(int currcons, int o break; case 20: /* Lf, Enter == CrLf/Lf */ if (on_off) - set_kbd(lnm); + set_kbd(vc, lnm); else - clr_kbd(lnm); + clr_kbd(vc, lnm); break; } } /* console_sem is held */ -static void setterm_command(int currcons) +static void setterm_command(struct vc_data *vc) { switch(par[0]) { case 1: /* set color for underline mode */ - if (vc_cons[currcons].d->vc_can_do_color && + if (vc->vc_can_do_color && par[1] < 16) { ulcolor = color_table[par[1]]; if (underline) - update_attr(currcons); + update_attr(vc); } break; case 2: /* set color for half intensity mode */ - if (vc_cons[currcons].d->vc_can_do_color && + if (vc->vc_can_do_color && par[1] < 16) { halfcolor = color_table[par[1]]; if (intensity == 0) - update_attr(currcons); + update_attr(vc); } break; case 8: /* store colors as defaults */ def_color = attr; if (hi_font_mask == 0x100) def_color >>= 1; - default_attr(currcons); - update_attr(currcons); + default_attr(vc); + update_attr(vc); break; case 9: /* set blanking interval */ blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ; @@ -1382,49 +1364,49 @@ static void setterm_command(int currcons } /* console_sem is held */ -static void csi_at(int currcons, unsigned int nr) +static void csi_at(struct vc_data *vc, unsigned int nr) { - if (nr > vc_cons[currcons].d->vc_cols - x) - nr = vc_cons[currcons].d->vc_cols - x; + if (nr > vc->vc_cols - x) + nr = vc->vc_cols - x; else if (!nr) nr = 1; - insert_char(currcons, nr); + insert_char(vc, nr); } /* console_sem is held */ -static void csi_L(int currcons, unsigned int nr) +static void csi_L(struct vc_data *vc, unsigned int nr) { - if (nr > vc_cons[currcons].d->vc_rows - y) - nr = vc_cons[currcons].d->vc_rows - y; + if (nr > vc->vc_rows - y) + nr = vc->vc_rows - y; else if (!nr) nr = 1; - scrdown(currcons,y,bottom,nr); + scrdown(vc, y, bottom, nr); need_wrap = 0; } /* console_sem is held */ -static void csi_P(int currcons, unsigned int nr) +static void csi_P(struct vc_data *vc, unsigned int nr) { - if (nr > vc_cons[currcons].d->vc_cols - x) - nr = vc_cons[currcons].d->vc_cols - x; + if (nr > vc->vc_cols - x) + nr = vc->vc_cols - x; else if (!nr) nr = 1; - delete_char(currcons, nr); + delete_char(vc, nr); } /* console_sem is held */ -static void csi_M(int currcons, unsigned int nr) +static void csi_M(struct vc_data *vc, unsigned int nr) { - if (nr > vc_cons[currcons].d->vc_rows - y) - nr = vc_cons[currcons].d->vc_rows - y; + if (nr > vc->vc_rows - y) + nr = vc->vc_rows - y; else if (!nr) nr=1; - scrup(currcons,y,bottom,nr); + scrup(vc, y, bottom, nr); need_wrap = 0; } /* console_sem is held (except via vc_init->reset_terminal */ -static void save_cur(int currcons) +static void save_cur(struct vc_data *vc) { saved_x = x; saved_y = y; @@ -1439,9 +1421,9 @@ static void save_cur(int currcons) } /* console_sem is held */ -static void restore_cur(int currcons) +static void restore_cur(struct vc_data *vc) { - gotoxy(vc_cons[currcons].d,saved_x,saved_y); + gotoxy(vc, saved_x, saved_y); intensity = s_intensity; underline = s_underline; blink = s_blink; @@ -1450,8 +1432,8 @@ static void restore_cur(int currcons) color = s_color; G0_charset = saved_G0; G1_charset = saved_G1; - translate = set_translate(charset ? G1_charset : G0_charset,currcons); - update_attr(currcons); + translate = set_translate(charset ? G1_charset : G0_charset, vc); + update_attr(vc); need_wrap = 0; } @@ -1460,13 +1442,13 @@ enum { ESnormal, ESesc, ESsquare, ESgetp ESpalette }; /* console_sem is held (except via vc_init()) */ -static void reset_terminal(int currcons, int do_clear) +static void reset_terminal(struct vc_data *vc, int do_clear) { top = 0; - bottom = vc_cons[currcons].d->vc_rows; + bottom = vc->vc_rows; vc_state = ESnormal; ques = 0; - translate = set_translate(LAT1_MAP,currcons); + translate = set_translate(LAT1_MAP, vc); G0_charset = LAT1_MAP; G1_charset = GRAF_MAP; charset = 0; @@ -1484,22 +1466,22 @@ static void reset_terminal(int currcons, deccm = 1; decim = 0; - set_kbd(decarm); - clr_kbd(decckm); - clr_kbd(kbdapplic); - clr_kbd(lnm); - kbd_table[currcons].lockstate = 0; - kbd_table[currcons].slockstate = 0; - kbd_table[currcons].ledmode = LED_SHOW_FLAGS; - kbd_table[currcons].ledflagstate = kbd_table[currcons].default_ledflagstate; + set_kbd(vc, decarm); + clr_kbd(vc, decckm); + clr_kbd(vc, kbdapplic); + clr_kbd(vc, lnm); + kbd_table[vc->vc_num].lockstate = 0; + kbd_table[vc->vc_num].slockstate = 0; + kbd_table[vc->vc_num].ledmode = LED_SHOW_FLAGS; + kbd_table[vc->vc_num].ledflagstate = kbd_table[vc->vc_num].default_ledflagstate; /* do not do set_leds here because this causes an endless tasklet loop when the keyboard hasn't been initialized yet */ cursor_type = CUR_DEFAULT; complement_mask = s_complement_mask; - default_attr(currcons); - update_attr(currcons); + default_attr(vc); + update_attr(vc); tab_stop[0] = 0x01010100; tab_stop[1] = @@ -1510,14 +1492,14 @@ static void reset_terminal(int currcons, bell_pitch = DEFAULT_BELL_PITCH; bell_duration = DEFAULT_BELL_DURATION; - gotoxy(vc_cons[currcons].d, 0, 0); - save_cur(currcons); + gotoxy(vc, 0, 0); + save_cur(vc); if (do_clear) - csi_J(currcons,2); + csi_J(vc, 2); } /* console_sem is held */ -static void do_con_trol(struct tty_struct *tty, unsigned int currcons, int c) +static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c) { /* * Control characters can be used in the _middle_ @@ -1531,11 +1513,11 @@ static void do_con_trol(struct tty_struc kd_mksound(bell_pitch, bell_duration); return; case 8: - bs(currcons); + bs(vc); return; case 9: pos -= (x << 1); - while (x < vc_cons[currcons].d->vc_cols - 1) { + while (x < vc->vc_cols - 1) { x++; if (tab_stop[x >> 5] & (1 << (x & 31))) break; @@ -1543,20 +1525,20 @@ static void do_con_trol(struct tty_struc pos += (x << 1); return; case 10: case 11: case 12: - lf(currcons); - if (!is_kbd(lnm)) + lf(vc); + if (!is_kbd(vc, lnm)) return; case 13: - cr(currcons); + cr(vc); return; case 14: charset = 1; - translate = set_translate(G1_charset,currcons); + translate = set_translate(G1_charset, vc); disp_ctrl = 1; return; case 15: charset = 0; - translate = set_translate(G0_charset,currcons); + translate = set_translate(G0_charset, vc); disp_ctrl = 0; return; case 24: case 26: @@ -1566,7 +1548,7 @@ static void do_con_trol(struct tty_struc vc_state = ESesc; return; case 127: - del(currcons); + del(vc); return; case 128+27: vc_state = ESsquare; @@ -1586,14 +1568,14 @@ static void do_con_trol(struct tty_struc vc_state = ESpercent; return; case 'E': - cr(currcons); - lf(currcons); + cr(vc); + lf(vc); return; case 'M': - ri(currcons); + ri(vc); return; case 'D': - lf(currcons); + lf(vc); return; case 'H': tab_stop[x >> 5] |= (1 << (x & 31)); @@ -1602,10 +1584,10 @@ static void do_con_trol(struct tty_struc respond_ID(tty); return; case '7': - save_cur(currcons); + save_cur(vc); return; case '8': - restore_cur(currcons); + restore_cur(vc); return; case '(': vc_state = ESsetG0; @@ -1617,13 +1599,13 @@ static void do_con_trol(struct tty_struc vc_state = EShash; return; case 'c': - reset_terminal(currcons,1); + reset_terminal(vc, 1); return; case '>': /* Numeric keypad */ - clr_kbd(kbdapplic); + clr_kbd(vc, kbdapplic); return; case '=': /* Appl. keypad */ - set_kbd(kbdapplic); + set_kbd(vc, kbdapplic); return; } return; @@ -1635,7 +1617,7 @@ static void do_con_trol(struct tty_struc vc_state = ESpalette; return; } else if (c=='R') { /* reset palette */ - reset_palette(currcons); + reset_palette(vc); vc_state = ESnormal; } else vc_state = ESnormal; @@ -1651,7 +1633,7 @@ static void do_con_trol(struct tty_struc palette[i++] += par[j++]; palette[i] = 16*par[j++]; palette[i] += par[j]; - set_palette(currcons); + set_palette(vc); vc_state = ESnormal; } } else @@ -1682,10 +1664,10 @@ static void do_con_trol(struct tty_struc vc_state = ESnormal; switch(c) { case 'h': - set_mode(currcons,1); + set_mode(vc, 1); return; case 'l': - set_mode(currcons,0); + set_mode(vc, 0); return; case 'c': if (ques) { @@ -1711,7 +1693,7 @@ static void do_con_trol(struct tty_struc if (par[0] == 5) status_report(tty); else if (par[0] == 6) - cursor_report(currcons,tty); + cursor_report(vc, tty); } return; } @@ -1722,55 +1704,55 @@ static void do_con_trol(struct tty_struc switch(c) { case 'G': case '`': if (par[0]) par[0]--; - gotoxy(vc_cons[currcons].d, par[0], y); + gotoxy(vc, par[0], y); return; case 'A': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, x, y-par[0]); + gotoxy(vc, x, y - par[0]); return; case 'B': case 'e': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, x, y+par[0]); + gotoxy(vc, x, y + par[0]); return; case 'C': case 'a': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, x+par[0], y); + gotoxy(vc, x + par[0], y); return; case 'D': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, x-par[0], y); + gotoxy(vc, x - par[0], y); return; case 'E': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, 0, y+par[0]); + gotoxy(vc, 0, y + par[0]); return; case 'F': if (!par[0]) par[0]++; - gotoxy(vc_cons[currcons].d, 0, y-par[0]); + gotoxy(vc, 0, y - par[0]); return; case 'd': if (par[0]) par[0]--; - gotoxay(currcons,x,par[0]); + gotoxay(vc, x, par[0]); return; case 'H': case 'f': if (par[0]) par[0]--; if (par[1]) par[1]--; - gotoxay(currcons,par[1],par[0]); + gotoxay(vc, par[1], par[0]); return; case 'J': - csi_J(currcons,par[0]); + csi_J(vc, par[0]); return; case 'K': - csi_K(currcons,par[0]); + csi_K(vc, par[0]); return; case 'L': - csi_L(currcons,par[0]); + csi_L(vc, par[0]); return; case 'M': - csi_M(currcons,par[0]); + csi_M(vc, par[0]); return; case 'P': - csi_P(currcons,par[0]); + csi_P(vc, par[0]); return; case 'c': if (!par[0]) @@ -1788,41 +1770,41 @@ static void do_con_trol(struct tty_struc } return; case 'm': - csi_m(currcons); + csi_m(vc); return; case 'q': /* DECLL - but only 3 leds */ /* map 0,1,2,3 to 0,1,2,4 */ if (par[0] < 4) - setledstate(kbd_table + currcons, + setledstate(kbd_table + vc->vc_num, (par[0] < 3) ? par[0] : 4); return; case 'r': if (!par[0]) par[0]++; if (!par[1]) - par[1] = vc_cons[currcons].d->vc_rows; + par[1] = vc->vc_rows; /* Minimum allowed region is 2 lines */ if (par[0] < par[1] && - par[1] <= vc_cons[currcons].d->vc_rows) { + par[1] <= vc->vc_rows) { top=par[0]-1; bottom=par[1]; - gotoxay(currcons,0,0); + gotoxay(vc, 0, 0); } return; case 's': - save_cur(currcons); + save_cur(vc); return; case 'u': - restore_cur(currcons); + restore_cur(vc); return; case 'X': - csi_X(currcons, par[0]); + csi_X(vc, par[0]); return; case '@': - csi_at(currcons,par[0]); + csi_at(vc, par[0]); return; case ']': /* setterm functions */ - setterm_command(currcons); + setterm_command(vc); return; } return; @@ -1847,10 +1829,10 @@ static void do_con_trol(struct tty_struc /* DEC screen alignment test. kludge :-) */ video_erase_char = (video_erase_char & 0xff00) | 'E'; - csi_J(currcons, 2); + csi_J(vc, 2); video_erase_char = (video_erase_char & 0xff00) | ' '; - do_update_region(vc_cons[currcons].d, origin, screenbuf_size/2); + do_update_region(vc, origin, screenbuf_size / 2); } return; case ESsetG0: @@ -1863,7 +1845,7 @@ static void do_con_trol(struct tty_struc else if (c == 'K') G0_charset = USER_MAP; if (charset == 0) - translate = set_translate(G0_charset,currcons); + translate = set_translate(G0_charset, vc); vc_state = ESnormal; return; case ESsetG1: @@ -1876,7 +1858,7 @@ static void do_con_trol(struct tty_struc else if (c == 'K') G1_charset = USER_MAP; if (charset == 1) - translate = set_translate(G1_charset,currcons); + translate = set_translate(G1_charset, vc); vc_state = ESnormal; return; default: @@ -1903,7 +1885,7 @@ static int do_con_write(struct tty_struc #define FLUSH do { } while(0); #else #define FLUSH if (draw_x >= 0) { \ - sw->con_putcs(vc_cons[currcons].d, (u16 *)draw_from, (u16 *)draw_to-(u16 *)draw_from, y, draw_x); \ + sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to-(u16 *)draw_from, y, draw_x); \ draw_x = -1; \ } #endif @@ -1912,6 +1894,7 @@ static int do_con_write(struct tty_struc unsigned int currcons; unsigned long draw_from = 0, draw_to = 0; struct vt_struct *vt; + struct vc_data *vc; u16 himask, charmask; const unsigned char *orig_buf = NULL; int orig_count; @@ -1940,6 +1923,7 @@ static int do_con_write(struct tty_struc release_console_sem(); return 0; } + vc = vc_cons[currcons].d; release_console_sem(); orig_buf = buf; @@ -1965,8 +1949,8 @@ static int do_con_write(struct tty_struc charmask = himask ? 0x1ff : 0xff; /* undraw cursor first */ - if (IS_FG) - hide_cursor(vc_cons[currcons].d); + if (currcons == fg_console) + hide_cursor(vc); while (!tty->stopped && count) { int orig = *buf; @@ -2034,11 +2018,11 @@ static int do_con_write(struct tty_struc if (vc_state == ESnormal && ok) { /* Now try to find out how to display it */ - tc = conv_uni_to_pc(vc_cons[currcons].d, tc); + tc = conv_uni_to_pc(vc, tc); if ( tc == -4 ) { /* If we got -4 (not found) then see if we have defined a replacement character (U+FFFD) */ - tc = conv_uni_to_pc(vc_cons[currcons].d, 0xfffd); + tc = conv_uni_to_pc(vc, 0xfffd); /* One reason for the -4 can be that we just did a clear_unimap(); @@ -2055,20 +2039,20 @@ static int do_con_write(struct tty_struc if (need_wrap || decim) FLUSH if (need_wrap) { - cr(currcons); - lf(currcons); + cr(vc); + lf(vc); } if (decim) - insert_char(currcons, 1); + insert_char(vc, 1); scr_writew(himask ? ((attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) : (attr << 8) + tc, (u16 *) pos); - if (DO_UPDATE && draw_x < 0) { + if (DO_UPDATE(vc) && draw_x < 0) { draw_x = x; draw_from = pos; } - if (x == vc_cons[currcons].d->vc_cols - 1) { + if (x == vc->vc_cols - 1) { need_wrap = decawm; draw_to = pos+2; } else { @@ -2078,7 +2062,7 @@ static int do_con_write(struct tty_struc continue; } FLUSH - do_con_trol(tty, currcons, orig); + do_con_trol(tty, vc, orig); } FLUSH console_conditional_schedule(); @@ -2106,7 +2090,7 @@ static void console_callback(void *ignor if (want_console != fg_console && vc_cons_allocated(want_console)) { hide_cursor(vc_cons[fg_console].d); - change_console(want_console); + change_console(vc_cons[want_console].d); /* we only changed when the console had already been allocated - a new console is not created in an interrupt routine */ @@ -2118,10 +2102,10 @@ static void console_callback(void *ignor poke_blanked_console(); } if (scrollback_delta) { - int currcons = fg_console; + struct vc_data *vc = vc_cons[fg_console].d; clear_selection(); if (vcmode == KD_TEXT) - sw->con_scrolldelta(vc_cons[currcons].d, scrollback_delta); + sw->con_scrolldelta(vc, scrollback_delta); scrollback_delta = 0; } if (blank_timer_expired) { @@ -2150,7 +2134,7 @@ struct tty_driver *console_driver; void vt_console_print(struct console *co, const char *b, unsigned count) { - int currcons = fg_console; + struct vc_data *vc = vc_cons[fg_console].d; unsigned char c; static unsigned long printing; const ushort *start; @@ -2162,13 +2146,13 @@ void vt_console_print(struct console *co return; if (kmsg_redirect && vc_cons_allocated(kmsg_redirect - 1)) - currcons = kmsg_redirect - 1; + vc = vc_cons[kmsg_redirect - 1].d; /* read `x' only after setting currcons properly (otherwise the `x' macro will read the x of the foreground console). */ myx = x; - if (!vc_cons_allocated(currcons)) { + if (!vc_cons_allocated(fg_console)) { /* impossible */ /* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */ goto quit; @@ -2178,8 +2162,8 @@ void vt_console_print(struct console *co goto quit; /* undraw cursor first */ - if (IS_FG) - hide_cursor(vc_cons[currcons].d); + if (vc->vc_num == fg_console) + hide_cursor(vc); start = (ushort *)pos; @@ -2189,22 +2173,22 @@ void vt_console_print(struct console *co c = *b++; if (c == 10 || c == 13 || c == 8 || need_wrap) { if (cnt > 0) { - if (IS_VISIBLE) - sw->con_putcs(vc_cons[currcons].d, start, cnt, y, x); + if (CON_IS_VISIBLE(vc)) + sw->con_putcs(vc, start, cnt, y, x); x += cnt; if (need_wrap) x--; cnt = 0; } if (c == 8) { /* backspace */ - bs(currcons); + bs(vc); start = (ushort *)pos; myx = x; continue; } if (c != 13) - lf(currcons); - cr(currcons); + lf(vc); + cr(vc); start = (ushort *)pos; myx = x; if (c == 10 || c == 13) @@ -2212,7 +2196,7 @@ void vt_console_print(struct console *co } scr_writew((attr << 8) + c, (unsigned short *) pos); cnt++; - if (myx == vc_cons[currcons].d->vc_cols - 1) { + if (myx == vc->vc_cols - 1) { need_wrap = 1; continue; } @@ -2220,15 +2204,15 @@ void vt_console_print(struct console *co myx++; } if (cnt > 0) { - if (IS_VISIBLE) - sw->con_putcs(vc_cons[currcons].d, start, cnt, y, x); + if (CON_IS_VISIBLE(vc)) + sw->con_putcs(vc, start, cnt, y, x); x += cnt; - if (x == vc_cons[currcons].d->vc_cols) { + if (x == vc->vc_cols) { x--; need_wrap = 1; } } - set_cursor(vc_cons[currcons].d); + set_cursor(vc); if (!oops_in_progress) poke_blanked_console(); @@ -2333,7 +2317,7 @@ int tioclinux(struct tty_struct *tty, un if (get_user(lines, (s32 __user *)(p+4))) { ret = -EFAULT; } else { - scrollfront(lines); + scrollfront(vc_cons[fg_console].d, lines); ret = 0; } break; @@ -2457,9 +2441,10 @@ static int con_open(struct tty_struct *t if (tty->count == 1) { ret = vc_allocate(currcons); if (ret == 0) { + struct vc_data *vc = vc_cons[currcons].d; vt_cons[currcons]->vc_num = currcons; tty->driver_data = vt_cons[currcons]; - vc_cons[currcons].d->vc_tty = tty; + vc->vc_tty = tty; if (!tty->winsize.ws_row && !tty->winsize.ws_col) { tty->winsize.ws_row = vc_cons[currcons].d->vc_rows; @@ -2505,29 +2490,29 @@ static void con_close(struct tty_struct up(&tty_sem); } -static void vc_init(unsigned int currcons, unsigned int rows, - unsigned int cols, int do_clear) +static void vc_init(struct vc_data *vc, unsigned int rows, + unsigned int cols, int do_clear) { int j, k ; - vc_cons[currcons].d->vc_cols = cols; - vc_cons[currcons].d->vc_rows = rows; - vc_cons[currcons].d->vc_size_row = cols<<1; - screenbuf_size = vc_cons[currcons].d->vc_rows * vc_cons[currcons].d->vc_size_row; + vc->vc_cols = cols; + vc->vc_rows = rows; + vc->vc_size_row = cols << 1; + screenbuf_size = vc->vc_rows * vc->vc_size_row; - set_origin(currcons); + set_origin(vc); pos = origin; - reset_vc(currcons); + reset_vc(vc); for (j=k=0; j<16; j++) { - vc_cons[currcons].d->vc_palette[k++] = default_red[j] ; - vc_cons[currcons].d->vc_palette[k++] = default_grn[j] ; - vc_cons[currcons].d->vc_palette[k++] = default_blu[j] ; + vc->vc_palette[k++] = default_red[j] ; + vc->vc_palette[k++] = default_grn[j] ; + vc->vc_palette[k++] = default_blu[j] ; } def_color = 0x07; /* white */ ulcolor = 0x0f; /* bold white */ halfcolor = 0x08; /* grey */ - init_waitqueue_head(&vt_cons[currcons]->paste_wait); - reset_terminal(currcons, do_clear); + init_waitqueue_head(&vt_cons[vc->vc_num]->paste_wait); + reset_terminal(vc, do_clear); } /* @@ -2539,6 +2524,7 @@ static void vc_init(unsigned int currcon static int __init con_init(void) { const char *display_desc = NULL; + struct vc_data *vc; unsigned int currcons = 0; acquire_console_sem(); @@ -2562,27 +2548,27 @@ static int __init con_init(void) * kmalloc is not running yet - we use the bootmem allocator. */ for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) { - vc_cons[currcons].d = (struct vc_data *) + vc_cons[currcons].d = vc = (struct vc_data *) alloc_bootmem(sizeof(struct vc_data)); vt_cons[currcons] = (struct vt_struct *) alloc_bootmem(sizeof(struct vt_struct)); vc_cons[currcons].d->vc_vt = vt_cons[currcons]; - visual_init(currcons, 1); + visual_init(vc, currcons, 1); screenbuf = (unsigned short *) alloc_bootmem(screenbuf_size); kmalloced = 0; - vc_init(currcons, vc_cons[currcons].d->vc_rows, vc_cons[currcons].d->vc_cols, + vc_init(vc, vc->vc_rows, vc->vc_cols, currcons || !sw->con_save_screen); } currcons = fg_console = 0; - master_display_fg = vc_cons[currcons].d; - set_origin(currcons); - save_screen(currcons); - gotoxy(vc_cons[currcons].d, x, y); - csi_J(currcons, 0); - update_screen(fg_console); + master_display_fg = vc = vc_cons[currcons].d; + set_origin(vc); + save_screen(vc); + gotoxy(vc, x, y); + csi_J(vc, 0); + update_screen(vc); printk("Console: %s %s %dx%d", - vc_cons[currcons].d->vc_can_do_color ? "colour" : "mono", - display_desc, vc_cons[currcons].d->vc_cols, vc_cons[currcons].d->vc_rows); + vc->vc_can_do_color ? "colour" : "mono", + display_desc, vc->vc_cols, vc->vc_rows); printable = 1; printk("\n"); @@ -2676,37 +2662,37 @@ int take_over_console(const struct consw for (i = first; i <= last; i++) { int old_was_color; - int currcons = i; + struct vc_data *vc = vc_cons[i].d; if (con_driver_map[i]) module_put(con_driver_map[i]->owner); __module_get(owner); con_driver_map[i] = csw; - if (!vc_cons[i].d || !vc_cons[i].d->vc_sw) + if (!vc || !vc->vc_sw) continue; j = i; - if (IS_VISIBLE) - save_screen(i); - old_was_color = vc_cons[i].d->vc_can_do_color; - vc_cons[i].d->vc_sw->con_deinit(vc_cons[i].d); + if (CON_IS_VISIBLE(vc)) + save_screen(vc); + old_was_color = vc->vc_can_do_color; + vc->vc_sw->con_deinit(vc); origin = (unsigned long) screenbuf; visible_origin = origin; scr_end = origin + screenbuf_size; - pos = origin + vc_cons[currcons].d->vc_size_row*y + 2*x; - visual_init(i, 0); - update_attr(i); + pos = origin + vc->vc_size_row * y + 2 * x; + visual_init(vc, i, 0); + update_attr(vc); /* If the console changed between mono <-> color, then * the attributes in the screenbuf will be wrong. The * following resets all attributes to something sane. */ - if (old_was_color != vc_cons[i].d->vc_can_do_color) - clear_buffer_attributes(i); + if (old_was_color != vc->vc_can_do_color) + clear_buffer_attributes(vc); - if (IS_VISIBLE) - update_screen(i); + if (CON_IS_VISIBLE(vc)) + update_screen(vc); } printk("Console: switching "); if (!deflt) @@ -2773,7 +2759,7 @@ static void vesa_powerdown(void) void do_blank_screen(int entering_gfx) { - int currcons = fg_console; + struct vc_data *vc = vc_cons[fg_console].d; int i; WARN_CONSOLE_UNLOCKED(); @@ -2792,11 +2778,11 @@ void do_blank_screen(int entering_gfx) /* entering graphics mode? */ if (entering_gfx) { - hide_cursor(vc_cons[currcons].d); - save_screen(currcons); - sw->con_blank(vc_cons[currcons].d, -1, 1); + hide_cursor(vc); + save_screen(vc); + sw->con_blank(vc, -1, 1); console_blanked = fg_console + 1; - set_origin(currcons); + set_origin(vc); return; } @@ -2806,16 +2792,16 @@ void do_blank_screen(int entering_gfx) return; } - hide_cursor(vc_cons[currcons].d); + hide_cursor(vc); del_timer_sync(&console_timer); blank_timer_expired = 0; - save_screen(currcons); + save_screen(vc); /* In case we need to reset origin, blanking hook returns 1 */ - i = sw->con_blank(vc_cons[currcons].d, 1, 0); + i = sw->con_blank(vc, 1, 0); console_blanked = fg_console + 1; if (i) - set_origin(currcons); + set_origin(vc); if (console_blank_hook && console_blank_hook(1)) return; @@ -2826,7 +2812,7 @@ void do_blank_screen(int entering_gfx) } if (vesa_blank_mode) - sw->con_blank(vc_cons[currcons].d, vesa_blank_mode + 1, 0); + sw->con_blank(vc, vesa_blank_mode + 1, 0); } EXPORT_SYMBOL(do_blank_screen); @@ -2835,7 +2821,7 @@ EXPORT_SYMBOL(do_blank_screen); */ void do_unblank_screen(int leaving_gfx) { - int currcons; + struct vc_data *vc; WARN_CONSOLE_UNLOCKED(); @@ -2847,7 +2833,7 @@ void do_unblank_screen(int leaving_gfx) printk("unblank_screen: tty %d not allocated ??\n", fg_console+1); return; } - currcons = fg_console; + vc = vc_cons[fg_console].d; if (vcmode != KD_TEXT) return; /* but leave console_blanked != 0 */ @@ -2857,13 +2843,13 @@ void do_unblank_screen(int leaving_gfx) } console_blanked = 0; - if (sw->con_blank(vc_cons[currcons].d, 0, leaving_gfx)) + if (sw->con_blank(vc, 0, leaving_gfx)) /* Low-level driver cannot restore -> do it ourselves */ - update_screen(fg_console); + update_screen(vc); if (console_blank_hook) console_blank_hook(0); - set_palette(currcons); - set_cursor(vc_cons[fg_console].d); + set_palette(vc); + set_cursor(vc); } EXPORT_SYMBOL(do_unblank_screen); @@ -2913,12 +2899,12 @@ void poke_blanked_console(void) * Palettes */ -void set_palette(int currcons) +void set_palette(struct vc_data *vc) { WARN_CONSOLE_UNLOCKED(); if (vcmode != KD_GRAPHICS) - sw->con_set_palette(vc_cons[currcons].d, color_table); + sw->con_set_palette(vc, color_table); } static int set_get_cmap(unsigned char __user *arg, int set) @@ -2945,7 +2931,7 @@ static int set_get_cmap(unsigned char __ vc_cons[i].d->vc_palette[k++] = default_grn[j]; vc_cons[i].d->vc_palette[k++] = default_blu[j]; } - set_palette(i); + set_palette(vc_cons[i].d); } } return 0; @@ -2978,7 +2964,7 @@ int con_get_cmap(unsigned char __user *a return rc; } -void reset_palette(int currcons) +void reset_palette(struct vc_data *vc) { int j, k; for (j=k=0; j<16; j++) { @@ -2986,7 +2972,7 @@ void reset_palette(int currcons) palette[k++] = default_grn[j]; palette[k++] = default_blu[j]; } - set_palette(currcons); + set_palette(vc); } /* @@ -3004,13 +2990,13 @@ void reset_palette(int currcons) #define max_font_size 65536 -int con_font_get(int currcons, struct console_font_op *op) +int con_font_get(struct vc_data *vc, struct console_font_op *op) { struct console_font font; int rc = -EINVAL; int c; - if (vt_cons[currcons]->vc_mode != KD_TEXT) + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT) return -EINVAL; if (op->data) { @@ -3022,7 +3008,7 @@ int con_font_get(int currcons, struct co acquire_console_sem(); if (sw->con_font_get) - rc = sw->con_font_get(vc_cons[currcons].d, &font); + rc = sw->con_font_get(vc, &font); else rc = -ENOSYS; release_console_sem(); @@ -3059,13 +3045,13 @@ out: return rc; } -int con_font_set(int currcons, struct console_font_op *op) +int con_font_set(struct vc_data *vc, struct console_font_op *op) { struct console_font font; int rc = -EINVAL; int size; - if (vt_cons[currcons]->vc_mode != KD_TEXT) + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT) return -EINVAL; if (!op->data) return -EINVAL; @@ -3108,7 +3094,7 @@ int con_font_set(int currcons, struct co } acquire_console_sem(); if (sw->con_font_set) - rc = sw->con_font_set(vc_cons[currcons].d, &font, op->flags); + rc = sw->con_font_set(vc, &font, op->flags); else rc = -ENOSYS; release_console_sem(); @@ -3116,14 +3102,14 @@ int con_font_set(int currcons, struct co return rc; } -int con_font_default(int currcons, struct console_font_op *op) +int con_font_default(struct vc_data *vc, struct console_font_op *op) { struct console_font font = {.width = op->width, .height = op->height}; char name[MAX_FONT_NAME]; char *s = name; int rc; - if (vt_cons[currcons]->vc_mode != KD_TEXT) + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT) return -EINVAL; if (!op->data) @@ -3135,7 +3121,7 @@ int con_font_default(int currcons, struc acquire_console_sem(); if (sw->con_font_default) - rc = sw->con_font_default(vc_cons[currcons].d, &font, s); + rc = sw->con_font_default(vc, &font, s); else rc = -ENOSYS; release_console_sem(); @@ -3146,17 +3132,15 @@ int con_font_default(int currcons, struc return rc; } -int con_font_copy(int currcons, struct console_font_op *op) +int con_font_copy(struct vc_data *vc, struct console_font_op *op) { int con = op->height; - struct vc_data *vc; int rc; - if (vt_cons[currcons]->vc_mode != KD_TEXT) + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT) return -EINVAL; acquire_console_sem(); - vc = vc_cons[currcons].d; if (!sw->con_font_copy) rc = -ENOSYS; else if (con < 0 || !vc_cons_allocated(con)) @@ -3169,17 +3153,17 @@ int con_font_copy(int currcons, struct c return rc; } -int con_font_op(int currcons, struct console_font_op *op) +int con_font_op(struct vc_data *vc, struct console_font_op *op) { switch (op->op) { case KD_FONT_OP_SET: - return con_font_set(currcons, op); + return con_font_set(vc, op); case KD_FONT_OP_GET: - return con_font_get(currcons, op); + return con_font_get(vc, op); case KD_FONT_OP_SET_DEFAULT: - return con_font_default(currcons, op); + return con_font_default(vc, op); case KD_FONT_OP_COPY: - return con_font_copy(currcons, op); + return con_font_copy(vc, op); } return -ENOSYS; } diff -puN drivers/char/vt_ioctl.c~cleanup-vc-array-access drivers/char/vt_ioctl.c --- 25/drivers/char/vt_ioctl.c~cleanup-vc-array-access 2005-01-23 14:46:33.141280312 -0800 +++ 25-akpm/drivers/char/vt_ioctl.c 2005-01-23 14:46:33.179274536 -0800 @@ -311,7 +311,7 @@ do_fontx_ioctl(int cmd, struct consolefo op->height = cfdarg.charheight; op->charcount = cfdarg.charcount; op->data = cfdarg.chardata; - return con_font_op(fg_console, op); + return con_font_op(vc_cons[fg_console].d, op); case GIO_FONTX: { op->op = KD_FONT_OP_GET; op->flags = KD_FONT_FLAG_OLD; @@ -319,7 +319,7 @@ do_fontx_ioctl(int cmd, struct consolefo op->height = cfdarg.charheight; op->charcount = cfdarg.charcount; op->data = cfdarg.chardata; - i = con_font_op(fg_console, op); + i = con_font_op(vc_cons[fg_console].d, op); if (i) return i; cfdarg.charheight = op->height; @@ -333,7 +333,7 @@ do_fontx_ioctl(int cmd, struct consolefo } static inline int -do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, unsigned int console) +do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, struct vc_data *vc) { struct unimapdesc tmp; int i = 0; @@ -349,11 +349,11 @@ do_unimap_ioctl(int cmd, struct unimapde case PIO_UNIMAP: if (!perm) return -EPERM; - return con_set_unimap(console, tmp.entry_ct, tmp.entries); + return con_set_unimap(vc, tmp.entry_ct, tmp.entries); case GIO_UNIMAP: - if (!perm && fg_console != console) + if (!perm && fg_console != vc->vc_num) return -EPERM; - return con_get_unimap(console, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); + return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); } return 0; } @@ -796,7 +796,7 @@ int vt_ioctl(struct tty_struct *tty, str * make sure we are atomic with respect to * other console switches.. */ - complete_change_console(newvt); + complete_change_console(vc_cons[newvt].d); release_console_sem(); } } @@ -852,7 +852,7 @@ int vt_ioctl(struct tty_struct *tty, str return -EFAULT; for (i = 0; i < MAX_NR_CONSOLES; i++) { acquire_console_sem(); - vc_resize(i, cc, ll); + vc_resize(vc_cons[i].d, cc, ll); release_console_sem(); } return 0; @@ -900,7 +900,7 @@ int vt_ioctl(struct tty_struct *tty, str vc_cons[i].d->vc_scan_lines = vlin; if (clin) vc_cons[i].d->vc_font.height = clin; - vc_resize(i, cc, ll); + vc_resize(vc_cons[i].d, cc, ll); release_console_sem(); } return 0; @@ -915,7 +915,7 @@ int vt_ioctl(struct tty_struct *tty, str op.height = 0; op.charcount = 256; op.data = up; - return con_font_op(fg_console, &op); + return con_font_op(vc_cons[fg_console].d, &op); } case GIO_FONT: { @@ -925,7 +925,7 @@ int vt_ioctl(struct tty_struct *tty, str op.height = 32; op.charcount = 256; op.data = up; - return con_font_op(fg_console, &op); + return con_font_op(vc_cons[fg_console].d, &op); } case PIO_CMAP: @@ -953,9 +953,10 @@ int vt_ioctl(struct tty_struct *tty, str { 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); + i = con_font_op(vc_cons[fg_console].d, &op); + if (i) + return i; + con_set_default_unimap(vc_cons[fg_console].d); return 0; } #endif @@ -966,7 +967,7 @@ int vt_ioctl(struct tty_struct *tty, str return -EFAULT; if (!perm && op.op != KD_FONT_OP_GET) return -EPERM; - i = con_font_op(console, &op); + i = con_font_op(vc, &op); if (i) return i; if (copy_to_user(up, &op, sizeof(op))) return -EFAULT; @@ -995,13 +996,13 @@ int vt_ioctl(struct tty_struct *tty, str return -EPERM; i = copy_from_user(&ui, up, sizeof(struct unimapinit)); if (i) return -EFAULT; - con_clear_unimap(console, &ui); + con_clear_unimap(vc, &ui); return 0; } case PIO_UNIMAP: case GIO_UNIMAP: - return do_unimap_ioctl(cmd, up, perm, console); + return do_unimap_ioctl(cmd, up, perm, vc); case VT_LOCKSWITCH: if (!capable(CAP_SYS_TTY_CONFIG)) @@ -1054,26 +1055,29 @@ int vt_waitactive(int vt) #define vt_wake_waitactive() wake_up(&vt_activate_queue) -void reset_vc(unsigned int new_console) +void reset_vc(struct vc_data *vc) { - 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; + struct vt_struct *vt = vt_cons[vc->vc_num]; + + vt->vc_mode = KD_TEXT; + kbd_table[vc->vc_num].kbdmode = VC_XLATE; + vt->vt_mode.mode = VT_AUTO; + vt->vt_mode.waitv = 0; + vt->vt_mode.relsig = 0; + vt->vt_mode.acqsig = 0; + vt->vt_mode.frsig = 0; + vt->vt_pid = -1; + vt->vt_newvt = -1; if (!in_interrupt()) /* Via keyboard.c:SAK() - akpm */ - reset_palette(new_console) ; + reset_palette(vc); } /* * Performs the back end of a vt switch */ -void complete_change_console(unsigned int new_console) +void complete_change_console(struct vc_data *vc) { + unsigned int new_console = vc->vc_num; unsigned char old_vc_mode; last_console = fg_console; @@ -1084,7 +1088,7 @@ void complete_change_console(unsigned in * unblank the screen later. */ old_vc_mode = vt_cons[fg_console]->vc_mode; - switch_screen(new_console); + switch_screen(vc); /* * This can't appear below a successful kill_proc(). If it did, @@ -1129,7 +1133,7 @@ void complete_change_console(unsigned in * 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); + reset_vc(vc); if (old_vc_mode != vt_cons[new_console]->vc_mode) { @@ -1151,11 +1155,9 @@ void complete_change_console(unsigned in /* * Performs the front-end of a vt switch */ -void change_console(unsigned int new_console) +void change_console(struct vc_data *new_vc) { - if ((new_console == fg_console) || (vt_dont_switch)) - return; - if (!vc_cons_allocated(new_console)) + if (!new_vc || new_vc->vc_num == fg_console || vt_dont_switch) return; /* @@ -1189,7 +1191,7 @@ void change_console(unsigned int new_con * return. The process needs to send us a * VT_RELDISP ioctl to complete the switch. */ - vt_cons[fg_console]->vt_newvt = new_console; + vt_cons[fg_console]->vt_newvt = new_vc->vc_num; return; } @@ -1202,7 +1204,7 @@ void change_console(unsigned int new_con * 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); + reset_vc(vc_cons[fg_console].d); /* * Fall through to normal (VT_AUTO) handling of the switch... @@ -1215,5 +1217,5 @@ void change_console(unsigned int new_con if (vt_cons[fg_console]->vc_mode == KD_GRAPHICS) return; - complete_change_console(new_console); + complete_change_console(new_vc); } diff -puN drivers/video/console/dummycon.c~cleanup-vc-array-access drivers/video/console/dummycon.c --- 25/drivers/video/console/dummycon.c~cleanup-vc-array-access 2005-01-23 14:46:33.142280160 -0800 +++ 25-akpm/drivers/video/console/dummycon.c 2005-01-23 14:46:33.179274536 -0800 @@ -42,7 +42,7 @@ static void dummycon_init(struct vc_data vc->vc_cols = DUMMY_COLUMNS; vc->vc_rows = DUMMY_ROWS; } else - vc_resize(vc->vc_num, DUMMY_COLUMNS, DUMMY_ROWS); + vc_resize(vc, DUMMY_COLUMNS, DUMMY_ROWS); } static int dummycon_dummy(void) diff -puN drivers/video/console/fbcon.c~cleanup-vc-array-access drivers/video/console/fbcon.c --- 25/drivers/video/console/fbcon.c~cleanup-vc-array-access 2005-01-23 14:46:33.144279856 -0800 +++ 25-akpm/drivers/video/console/fbcon.c 2005-01-23 14:46:33.183273928 -0800 @@ -458,7 +458,7 @@ static void fbcon_prepare_logo(struct vc if (CON_IS_VISIBLE(vc) && vt_cons[vc->vc_num]->vc_mode == KD_TEXT) { fbcon_clear_margins(vc, 0); - update_screen(vc->vc_num); + update_screen(vc); } if (save) { @@ -609,7 +609,7 @@ static void con2fb_init_display(struct v fg_vc->vc_rows); } - switch_screen(fg_console); + switch_screen(vc_cons[fg_console].d); } /** @@ -802,7 +802,7 @@ static const char *fbcon_startup(void) cols = info->var.xres / vc->vc_font.width; rows = info->var.yres / vc->vc_font.height; - vc_resize(vc->vc_num, cols, rows); + vc_resize(vc, cols, rows); DPRINTK("mode: %s\n", info->fix.id); DPRINTK("visual: %d\n", info->fix.visual); @@ -890,13 +890,12 @@ static void fbcon_init(struct vc_data *v struct vc_data **default_mode = vc->vc_display_fg; struct vc_data *svc = *default_mode; struct display *t, *p = &fb_display[vc->vc_num]; - int display_fg = (*default_mode)->vc_num; int logo = 1, new_rows, new_cols, rows, cols, charcnt = 256; int cap = info->flags; if (info_idx == -1 || info == NULL) return; - if (vc->vc_num != display_fg || logo_shown == FBCON_LOGO_DONTSHOW || + if (vc != svc || logo_shown == FBCON_LOGO_DONTSHOW || (info->fix.type == FB_TYPE_TEXT)) logo = 0; @@ -907,7 +906,7 @@ static void fbcon_init(struct vc_data *v /* If we are not the first console on this fb, copy the font from that console */ - t = &fb_display[display_fg]; + t = &fb_display[svc->vc_num]; if (!vc->vc_font.data) { vc->vc_font.data = p->fontdata = t->fontdata; vc->vc_font.width = (*default_mode)->vc_font.width; @@ -929,15 +928,15 @@ static void fbcon_init(struct vc_data *v } if (!*svc->vc_uni_pagedir_loc) - con_set_default_unimap(display_fg); + con_set_default_unimap(svc); if (!*vc->vc_uni_pagedir_loc) - con_copy_unimap(vc->vc_num, display_fg); + con_copy_unimap(vc, svc); cols = vc->vc_cols; rows = vc->vc_rows; new_cols = info->var.xres / vc->vc_font.width; new_rows = info->var.yres / vc->vc_font.height; - vc_resize(vc->vc_num, new_cols, new_rows); + vc_resize(vc, new_cols, new_rows); /* * We must always set the mode. The mode of the previous console * driver could be in the same resolution but we are using different @@ -968,7 +967,7 @@ static void fbcon_init(struct vc_data *v if (logo) fbcon_prepare_logo(vc, info, cols, rows, new_cols, new_rows); - if (vc->vc_num == display_fg && softback_buf) { + if (vc == svc && softback_buf) { int l = fbcon_softback_size / vc->vc_size_row; if (l > 5) softback_end = softback_buf + l * vc->vc_size_row; @@ -1144,13 +1143,12 @@ static void fbcon_set_disp(struct fb_inf struct display *p = &fb_display[vc->vc_num], *t; struct vc_data **default_mode = vc->vc_display_fg; struct vc_data *svc = *default_mode; - int display_fg = (*default_mode)->vc_num; int rows, cols, charcnt = 256; info->var.xoffset = info->var.yoffset = p->yscroll = 0; if (var_to_display(p, &info->var, info)) return; - t = &fb_display[display_fg]; + t = &fb_display[svc->vc_num]; if (!vc->vc_font.data) { vc->vc_font.data = p->fontdata = t->fontdata; vc->vc_font.width = (*default_mode)->vc_font.width; @@ -1173,15 +1171,15 @@ static void fbcon_set_disp(struct fb_inf } if (!*svc->vc_uni_pagedir_loc) - con_set_default_unimap(display_fg); + con_set_default_unimap(svc); if (!*vc->vc_uni_pagedir_loc) - con_copy_unimap(vc->vc_num, display_fg); + con_copy_unimap(vc, svc); cols = info->var.xres / vc->vc_font.width; rows = info->var.yres / vc->vc_font.height; - vc_resize(vc->vc_num, cols, rows); + vc_resize(vc, cols, rows); if (CON_IS_VISIBLE(vc)) { - update_screen(vc->vc_num); + update_screen(vc); if (softback_buf) { int l = fbcon_softback_size / vc->vc_size_row; @@ -1987,7 +1985,7 @@ static int fbcon_switch(struct vc_data * logo_shown = fg_console; /* This is protected above by initmem_freed */ fb_show_logo(info); - update_region(fg_console, + update_region(vc, vc->vc_origin + vc->vc_size_row * vc->vc_top, vc->vc_size_row * (vc->vc_bottom - vc->vc_top) / 2); @@ -2048,7 +2046,7 @@ static int fbcon_blank(struct vc_data *v } if (!blank) - update_screen(vc->vc_num); + update_screen(vc); } return 0; @@ -2198,7 +2196,7 @@ static int fbcon_do_set_font(struct vc_d if (resize) { /* reset wrap/pan */ info->var.xoffset = info->var.yoffset = p->yscroll = 0; - vc_resize(vc->vc_num, info->var.xres / w, info->var.yres / h); + vc_resize(vc, info->var.xres / w, info->var.yres / h); if (CON_IS_VISIBLE(vc) && softback_buf) { int l = fbcon_softback_size / vc->vc_size_row; if (l > 5) @@ -2213,7 +2211,7 @@ static int fbcon_do_set_font(struct vc_d } else if (CON_IS_VISIBLE(vc) && vt_cons[vc->vc_num]->vc_mode == KD_TEXT) { fbcon_clear_margins(vc, 0); - update_screen(vc->vc_num); + update_screen(vc); } if (old_data && (--REFCOUNT(old_data) == 0)) @@ -2464,7 +2462,7 @@ static int fbcon_scrolldelta(struct vc_d vc->vc_size_row); } softback_in = p; - update_region(vc->vc_num, vc->vc_origin, + update_region(vc, vc->vc_origin, logo_lines * vc->vc_cols); } logo_shown = FBCON_LOGO_CANSHOW; @@ -2545,7 +2543,7 @@ static void fbcon_resumed(struct fb_info return; vc = vc_cons[ops->currcon].d; - update_screen(vc->vc_num); + update_screen(vc); } static void fbcon_modechanged(struct fb_info *info) @@ -2569,13 +2567,13 @@ static void fbcon_modechanged(struct fb_ var_to_display(p, &info->var, info); cols = info->var.xres / vc->vc_font.width; rows = info->var.yres / vc->vc_font.height; - vc_resize(vc->vc_num, cols, rows); + vc_resize(vc, cols, rows); updatescrollmode(p, info, vc); scrollback_max = 0; scrollback_current = 0; update_var(vc->vc_num, info); fbcon_set_palette(vc, color_table); - update_screen(vc->vc_num); + update_screen(vc); if (softback_buf) { int l = fbcon_softback_size / vc->vc_size_row; if (l > 5) diff -puN drivers/video/console/mdacon.c~cleanup-vc-array-access drivers/video/console/mdacon.c --- 25/drivers/video/console/mdacon.c~cleanup-vc-array-access 2005-01-23 14:46:33.145279704 -0800 +++ 25-akpm/drivers/video/console/mdacon.c 2005-01-23 14:46:33.183273928 -0800 @@ -351,10 +351,9 @@ static void mdacon_init(struct vc_data * if (init) { c->vc_cols = mda_num_columns; c->vc_rows = mda_num_lines; - } else { - vc_resize(c->vc_num, mda_num_columns, mda_num_lines); - } - + } else + vc_resize(c, mda_num_columns, mda_num_lines); + /* make the first MDA console visible */ if (mda_display_fg == NULL) diff -puN drivers/video/console/promcon.c~cleanup-vc-array-access drivers/video/console/promcon.c --- 25/drivers/video/console/promcon.c~cleanup-vc-array-access 2005-01-23 14:46:33.146279552 -0800 +++ 25-akpm/drivers/video/console/promcon.c 2005-01-23 14:46:33.184273776 -0800 @@ -155,9 +155,9 @@ promcon_init_unimap(struct vc_data *conp k++; } set_fs(KERNEL_DS); - con_clear_unimap(conp->vc_num, NULL); - con_set_unimap(conp->vc_num, k, p); - con_protect_unimap(conp->vc_num, 1); + con_clear_unimap(conp, NULL); + con_set_unimap(conp, k, p); + con_protect_unimap(conp, 1); set_fs(old_fs); kfree(p); } @@ -175,7 +175,7 @@ promcon_init(struct vc_data *conp, int i p = *conp->vc_uni_pagedir_loc; if (conp->vc_uni_pagedir_loc == &conp->vc_uni_pagedir || !--conp->vc_uni_pagedir_loc[1]) - con_free_unimap(conp->vc_num); + con_free_unimap(conp); conp->vc_uni_pagedir_loc = promcon_uni_pagedir; promcon_uni_pagedir[1]++; if (!promcon_uni_pagedir[0] && p) { @@ -183,7 +183,7 @@ promcon_init(struct vc_data *conp, int i } if (!init) { if (conp->vc_cols != pw + 1 || conp->vc_rows != ph + 1) - vc_resize(conp->vc_num, pw + 1, ph + 1); + vc_resize(conp, pw + 1, ph + 1); } } @@ -192,9 +192,9 @@ promcon_deinit(struct vc_data *conp) { /* When closing the last console, reset video origin */ if (!--promcon_uni_pagedir[1]) - con_free_unimap(conp->vc_num); + con_free_unimap(conp); conp->vc_uni_pagedir_loc = &conp->vc_uni_pagedir; - con_set_default_unimap(conp->vc_num); + con_set_default_unimap(conp); } static int diff -puN drivers/video/console/sticon.c~cleanup-vc-array-access drivers/video/console/sticon.c --- 25/drivers/video/console/sticon.c~cleanup-vc-array-access 2005-01-23 14:46:33.148279248 -0800 +++ 25-akpm/drivers/video/console/sticon.c 2005-01-23 14:46:33.185273624 -0800 @@ -217,7 +217,7 @@ static void sticon_init(struct vc_data * } else { /* vc_rows = (c->vc_rows > vc_rows) ? vc_rows : c->vc_rows; */ /* vc_cols = (c->vc_cols > vc_cols) ? vc_cols : c->vc_cols; */ - vc_resize(c->vc_num, vc_cols, vc_rows); + vc_resize(c, vc_cols, vc_rows); /* vc_resize_con(vc_rows, vc_cols, c->vc_num); */ } } diff -puN drivers/video/console/vgacon.c~cleanup-vc-array-access drivers/video/console/vgacon.c --- 25/drivers/video/console/vgacon.c~cleanup-vc-array-access 2005-01-23 14:46:33.149279096 -0800 +++ 25-akpm/drivers/video/console/vgacon.c 2005-01-23 14:46:33.186273472 -0800 @@ -340,11 +340,11 @@ static void vgacon_init(struct vc_data * p = *c->vc_uni_pagedir_loc; if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir || !--c->vc_uni_pagedir_loc[1]) - con_free_unimap(c->vc_num); + con_free_unimap(c); c->vc_uni_pagedir_loc = vgacon_uni_pagedir; vgacon_uni_pagedir[1]++; if (!vgacon_uni_pagedir[0] && p) - con_set_default_unimap(c->vc_num); + con_set_default_unimap(c); } static inline void vga_set_mem_top(struct vc_data *c) @@ -358,10 +358,10 @@ static void vgacon_deinit(struct vc_data if (!--vgacon_uni_pagedir[1]) { c->vc_visible_origin = vga_vram_base; vga_set_mem_top(c); - con_free_unimap(c->vc_num); + con_free_unimap(c); } c->vc_uni_pagedir_loc = &c->vc_uni_pagedir; - con_set_default_unimap(c->vc_num); + con_set_default_unimap(c); } static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity, @@ -908,7 +908,7 @@ static int vgacon_adjust_height(struct v c->vc_sw->con_cursor(c, CM_DRAW); } c->vc_font.height = fontheight; - vc_resize(c->vc_num, 0, rows); /* Adjust console size */ + vc_resize(c, 0, rows); /* Adjust console size */ } } return 0; diff -puN fs/compat_ioctl.c~cleanup-vc-array-access fs/compat_ioctl.c --- 25/fs/compat_ioctl.c~cleanup-vc-array-access 2005-01-23 14:46:33.151278792 -0800 +++ 25-akpm/fs/compat_ioctl.c 2005-01-23 14:46:33.189273016 -0800 @@ -1612,7 +1612,7 @@ static int do_fontx_ioctl(unsigned int f get_user(data, &user_cfd->chardata)) return -EFAULT; op.data = compat_ptr(data); - return con_font_op(fg_console, &op); + return con_font_op(vc_cons[fg_console].d, &op); case GIO_FONTX: op.op = KD_FONT_OP_GET; op.flags = 0; @@ -1624,7 +1624,7 @@ static int do_fontx_ioctl(unsigned int f if (!data) return 0; op.data = compat_ptr(data); - i = con_font_op(fg_console, &op); + i = con_font_op(vc_cons[fg_console].d, &op); if (i) return i; if (put_user(op.height, &user_cfd->charheight) || @@ -1661,7 +1661,7 @@ static int do_kdfontop_ioctl(unsigned in op.data = compat_ptr(((struct console_font_op32 *)&op)->data); op.flags |= KD_FONT_FLAG_OLD; vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data; - i = con_font_op(vt->vc_num, &op); + i = con_font_op(vc_cons[vt->vc_num].d, &op); if (i) return i; ((struct console_font_op32 *)&op)->data = (unsigned long)op.data; if (copy_to_user(fontop, &op, sizeof(struct console_font_op32))) @@ -1686,9 +1686,9 @@ static int do_unimap_ioctl(unsigned int switch (cmd) { case PIO_UNIMAP: if (!perm) return -EPERM; - return con_set_unimap(fg_console, tmp.entry_ct, compat_ptr(tmp.entries)); + return con_set_unimap(vc_cons[fg_console].d, tmp.entry_ct, compat_ptr(tmp.entries)); case GIO_UNIMAP: - return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), compat_ptr(tmp.entries)); + return con_get_unimap(vc_cons[fg_console].d, tmp.entry_ct, &(user_ud->entry_ct), compat_ptr(tmp.entries)); } return 0; } diff -puN include/linux/consolemap.h~cleanup-vc-array-access include/linux/consolemap.h --- 25/include/linux/consolemap.h~cleanup-vc-array-access 2005-01-23 14:46:33.153278488 -0800 +++ 25-akpm/include/linux/consolemap.h 2005-01-23 14:46:33.189273016 -0800 @@ -11,5 +11,5 @@ struct vc_data; extern unsigned char inverse_translate(struct vc_data *conp, int glyph); -extern unsigned short *set_translate(int m,int currcons); +extern unsigned short *set_translate(int m, struct vc_data *vc); extern int conv_uni_to_pc(struct vc_data *conp, long ucs); diff -puN include/linux/vt_kern.h~cleanup-vc-array-access include/linux/vt_kern.h --- 25/include/linux/vt_kern.h~cleanup-vc-array-access 2005-01-23 14:46:33.154278336 -0800 +++ 25-akpm/include/linux/vt_kern.h 2005-01-23 14:46:33.190272864 -0800 @@ -41,25 +41,25 @@ extern int kbd_rate(struct kbd_repeat *r int vc_allocate(unsigned int console); int vc_cons_allocated(unsigned int console); -int vc_resize(int currcons, unsigned int cols, unsigned int lines); +int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines); void vc_disallocate(unsigned int console); -void reset_palette(int currcons); -void set_palette(int currcons); +void reset_palette(struct vc_data *vc); +void set_palette(struct vc_data *vc); void do_blank_screen(int entering_gfx); void do_unblank_screen(int leaving_gfx); void unblank_screen(void); void poke_blanked_console(void); -int con_font_op(int currcons, struct console_font_op *op); -int con_font_set(int currcons, struct console_font_op *op); -int con_font_get(int currcons, struct console_font_op *op); -int con_font_default(int currcons, struct console_font_op *op); -int con_font_copy(int currcons, struct console_font_op *op); +int con_font_op(struct vc_data *vc, struct console_font_op *op); +int con_font_set(struct vc_data *vc, struct console_font_op *op); +int con_font_get(struct vc_data *vc, struct console_font_op *op); +int con_font_default(struct vc_data *vc, struct console_font_op *op); +int con_font_copy(struct vc_data *vc, struct console_font_op *op); int con_set_cmap(unsigned char __user *cmap); int con_get_cmap(unsigned char __user *cmap); -void scrollback(int); -void scrollfront(int); -void update_region(int currcons, unsigned long start, int count); -void redraw_screen(int new_console, int is_switch); +void scrollback(struct vc_data *vc, int lines); +void scrollfront(struct vc_data *vc, int lines); +void update_region(struct vc_data *vc, unsigned long start, int count); +void redraw_screen(struct vc_data *vc, int is_switch); #define update_screen(x) redraw_screen(x, 0) #define switch_screen(x) redraw_screen(x, 1) @@ -75,19 +75,19 @@ int con_set_trans_old(unsigned char __us int con_get_trans_old(unsigned char __user * table); int con_set_trans_new(unsigned short __user * table); int con_get_trans_new(unsigned short __user * table); -int con_clear_unimap(int currcons, struct unimapinit *ui); -int con_set_unimap(int currcons, ushort ct, struct unipair __user *list); -int con_get_unimap(int currcons, ushort ct, ushort __user *uct, struct unipair __user *list); -int con_set_default_unimap(int currcons); -void con_free_unimap(int currcons); -void con_protect_unimap(int currcons, int rdonly); -int con_copy_unimap(int dstcons, int srccons); +int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui); +int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list); +int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list); +int con_set_default_unimap(struct vc_data *vc); +void con_free_unimap(struct vc_data *vc); +void con_protect_unimap(struct vc_data *vc, int rdonly); +int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc); /* vt.c */ -void complete_change_console(unsigned int new_console); +void complete_change_console(struct vc_data *vc); int vt_waitactive(int vt); -void change_console(unsigned int); -void reset_vc(unsigned int new_console); +void change_console(struct vc_data *new_vc); +void reset_vc(struct vc_data *vc); /* * vc_screen.c shares this temporary buffer with the console write code so that _