[linux-2.6-block.git] / drivers / tty / vt / selection.c

// SPDX-License-Identifier: GPL-2.0
/*
 * This module exports the functions:
 *
 *     'int set_selection_user(struct tiocl_selection __user *,
 *			       struct tty_struct *)'
 *     'int set_selection_kernel(struct tiocl_selection *, struct tty_struct *)'
 *     'void clear_selection(void)'
 *     'int paste_selection(struct tty_struct *)'
 *     'int sel_loadlut(u32 __user *)'
 *
 * Now that /dev/vcs exists, most of this can disappear again.
 */

#include <linux/module.h>
#include <linux/tty.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/types.h>

#include <linux/uaccess.h>

#include <linux/kbd_kern.h>
#include <linux/vt_kern.h>
#include <linux/consolemap.h>
#include <linux/selection.h>
#include <linux/tiocl.h>
#include <linux/console.h>
#include <linux/tty_flip.h>

#include <linux/sched/signal.h>

/* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */
#define is_space_on_vt(c)	((c) == ' ')

/* FIXME: all this needs locking */
static struct vc_selection {
	struct mutex lock;
	struct vc_data *cons;			/* must not be deallocated */
	char *buffer;
	unsigned int buf_len;
	volatile int start;			/* cleared by clear_selection */
	int end;
} vc_sel = {
	.lock = __MUTEX_INITIALIZER(vc_sel.lock),
	.start = -1,
};

/* clear_selection, highlight and highlight_pointer can be called
   from interrupt (via scrollback/front) */

/* set reverse video on characters s-e of console with selection. */
static inline void highlight(const int s, const int e)
{
	invert_screen(vc_sel.cons, s, e-s+2, true);
}

/* use complementary color to show the pointer */
static inline void highlight_pointer(const int where)
{
	complement_pos(vc_sel.cons, where);
}

static u32
sel_pos(int n, bool unicode)
{
	if (unicode)
		return screen_glyph_unicode(vc_sel.cons, n / 2);
	return inverse_translate(vc_sel.cons, screen_glyph(vc_sel.cons, n),
			false);
}

/**
 * clear_selection - remove current selection
 *
 * Remove the current selection highlight, if any from the console holding the
 * selection.
 *
 * Locking: The caller must hold the console lock.
 */
void clear_selection(void)
{
	highlight_pointer(-1); /* hide the pointer */
	if (vc_sel.start != -1) {
		highlight(vc_sel.start, vc_sel.end);
		vc_sel.start = -1;
	}
}
EXPORT_SYMBOL_GPL(clear_selection);

bool vc_is_sel(const struct vc_data *vc)
{
	return vc == vc_sel.cons;
}

/*
 * User settable table: what characters are to be considered alphabetic?
 * 128 bits. Locked by the console lock.
 */
static u32 inwordLut[]={
  0x00000000, /* control chars     */
  0x03FFE000, /* digits and "-./"  */
  0x87FFFFFE, /* uppercase and '_' */
  0x07FFFFFE, /* lowercase         */
};

static inline int inword(const u32 c)
{
	return c > 0x7f || (( inwordLut[c>>5] >> (c & 0x1F) ) & 1);
}

/**
 * sel_loadlut() - load the LUT table
 * @lut: user table
 *
 * Load the LUT table from user space. Make a temporary copy so a partial
 * update doesn't make a mess.
 *
 * Locking: The console lock is acquired.
 */
int sel_loadlut(u32 __user *lut)
{
	u32 tmplut[ARRAY_SIZE(inwordLut)];

	if (copy_from_user(tmplut, lut, sizeof(inwordLut)))
		return -EFAULT;

	console_lock();
	memcpy(inwordLut, tmplut, sizeof(inwordLut));
	console_unlock();

	return 0;
}

/* does screen address p correspond to character at LH/RH edge of screen? */
static inline int atedge(const int p, int size_row)
{
	return (!(p % size_row)	|| !((p + 2) % size_row));
}

/* stores the char in UTF8 and returns the number of bytes used (1-4) */
static int store_utf8(u32 c, char *p)
{
	if (c < 0x80) {
		/*  0******* */
		p[0] = c;
		return 1;
	} else if (c < 0x800) {
		/* 110***** 10****** */
		p[0] = 0xc0 | (c >> 6);
		p[1] = 0x80 | (c & 0x3f);
		return 2;
	} else if (c < 0x10000) {
		/* 1110**** 10****** 10****** */
		p[0] = 0xe0 | (c >> 12);
		p[1] = 0x80 | ((c >> 6) & 0x3f);
		p[2] = 0x80 | (c & 0x3f);
		return 3;
	} else if (c < 0x110000) {
		/* 11110*** 10****** 10****** 10****** */
		p[0] = 0xf0 | (c >> 18);
		p[1] = 0x80 | ((c >> 12) & 0x3f);
		p[2] = 0x80 | ((c >> 6) & 0x3f);
		p[3] = 0x80 | (c & 0x3f);
		return 4;
	} else {
		/* outside Unicode, replace with U+FFFD */
		p[0] = 0xef;
		p[1] = 0xbf;
		p[2] = 0xbd;
		return 3;
	}
}

/**
 * set_selection_user - set the current selection.
 * @sel: user selection info
 * @tty: the console tty
 *
 * Invoked by the ioctl handle for the vt layer.
 *
 * Locking: The entire selection process is managed under the console_lock.
 * It's a lot under the lock but its hardly a performance path.
 */
int set_selection_user(const struct tiocl_selection __user *sel,
		       struct tty_struct *tty)
{
	struct tiocl_selection v;

	if (copy_from_user(&v, sel, sizeof(*sel)))
		return -EFAULT;

	return set_selection_kernel(&v, tty);
}

static int vc_selection_store_chars(struct vc_data *vc, bool unicode)
{
	char *bp, *obp;
	unsigned int i;

	/* Allocate a new buffer before freeing the old one ... */
	/* chars can take up to 4 bytes with unicode */
	bp = kmalloc_array((vc_sel.end - vc_sel.start) / 2 + 1, unicode ? 4 : 1,
			   GFP_KERNEL | __GFP_NOWARN);
	if (!bp) {
		printk(KERN_WARNING "selection: kmalloc() failed\n");
		clear_selection();
		return -ENOMEM;
	}
	kfree(vc_sel.buffer);
	vc_sel.buffer = bp;

	obp = bp;
	for (i = vc_sel.start; i <= vc_sel.end; i += 2) {
		u32 c = sel_pos(i, unicode);
		if (unicode)
			bp += store_utf8(c, bp);
		else
			*bp++ = c;
		if (!is_space_on_vt(c))
			obp = bp;
		if (!((i + 2) % vc->vc_size_row)) {
			/* strip trailing blanks from line and add newline,
			   unless non-space at end of line. */
			if (obp != bp) {
				bp = obp;
				*bp++ = '\r';
			}
			obp = bp;
		}
	}
	vc_sel.buf_len = bp - vc_sel.buffer;

	return 0;
}

static int vc_do_selection(struct vc_data *vc, unsigned short mode, int ps,
		int pe)
{
	int new_sel_start, new_sel_end, spc;
	bool unicode = vt_do_kdgkbmode(fg_console) == K_UNICODE;

	switch (mode) {
	case TIOCL_SELCHAR:	/* character-by-character selection */
		new_sel_start = ps;
		new_sel_end = pe;
		break;
	case TIOCL_SELWORD:	/* word-by-word selection */
		spc = is_space_on_vt(sel_pos(ps, unicode));
		for (new_sel_start = ps; ; ps -= 2) {
			if ((spc && !is_space_on_vt(sel_pos(ps, unicode))) ||
			    (!spc && !inword(sel_pos(ps, unicode))))
				break;
			new_sel_start = ps;
			if (!(ps % vc->vc_size_row))
				break;
		}

		spc = is_space_on_vt(sel_pos(pe, unicode));
		for (new_sel_end = pe; ; pe += 2) {
			if ((spc && !is_space_on_vt(sel_pos(pe, unicode))) ||
			    (!spc && !inword(sel_pos(pe, unicode))))
				break;
			new_sel_end = pe;
			if (!((pe + 2) % vc->vc_size_row))
				break;
		}
		break;
	case TIOCL_SELLINE:	/* line-by-line selection */
		new_sel_start = rounddown(ps, vc->vc_size_row);
		new_sel_end = rounddown(pe, vc->vc_size_row) +
			vc->vc_size_row - 2;
		break;
	case TIOCL_SELPOINTER:
		highlight_pointer(pe);
		return 0;
	default:
		return -EINVAL;
	}

	/* remove the pointer */
	highlight_pointer(-1);

	/* select to end of line if on trailing space */
	if (new_sel_end > new_sel_start &&
		!atedge(new_sel_end, vc->vc_size_row) &&
		is_space_on_vt(sel_pos(new_sel_end, unicode))) {
		for (pe = new_sel_end + 2; ; pe += 2)
			if (!is_space_on_vt(sel_pos(pe, unicode)) ||
			    atedge(pe, vc->vc_size_row))
				break;
		if (is_space_on_vt(sel_pos(pe, unicode)))
			new_sel_end = pe;
	}
	if (vc_sel.start == -1)	/* no current selection */
		highlight(new_sel_start, new_sel_end);
	else if (new_sel_start == vc_sel.start)
	{
		if (new_sel_end == vc_sel.end)	/* no action required */
			return 0;
		else if (new_sel_end > vc_sel.end)	/* extend to right */
			highlight(vc_sel.end + 2, new_sel_end);
		else				/* contract from right */
			highlight(new_sel_end + 2, vc_sel.end);
	}
	else if (new_sel_end == vc_sel.end)
	{
		if (new_sel_start < vc_sel.start) /* extend to left */
			highlight(new_sel_start, vc_sel.start - 2);
		else				/* contract from left */
			highlight(vc_sel.start, new_sel_start - 2);
	}
	else	/* some other case; start selection from scratch */
	{
		clear_selection();
		highlight(new_sel_start, new_sel_end);
	}
	vc_sel.start = new_sel_start;
	vc_sel.end = new_sel_end;

	return vc_selection_store_chars(vc, unicode);
}

static int vc_selection(struct vc_data *vc, struct tiocl_selection *v,
		struct tty_struct *tty)
{
	int ps, pe;

	poke_blanked_console();

	if (v->sel_mode == TIOCL_SELCLEAR) {
		/* useful for screendump without selection highlights */
		clear_selection();
		return 0;
	}

	v->xs = min_t(u16, v->xs - 1, vc->vc_cols - 1);
	v->ys = min_t(u16, v->ys - 1, vc->vc_rows - 1);
	v->xe = min_t(u16, v->xe - 1, vc->vc_cols - 1);
	v->ye = min_t(u16, v->ye - 1, vc->vc_rows - 1);

	if (mouse_reporting() && (v->sel_mode & TIOCL_SELMOUSEREPORT)) {
		mouse_report(tty, v->sel_mode & TIOCL_SELBUTTONMASK, v->xs,
			     v->ys);
		return 0;
	}

	ps = v->ys * vc->vc_size_row + (v->xs << 1);
	pe = v->ye * vc->vc_size_row + (v->xe << 1);
	if (ps > pe)	/* make vc_sel.start <= vc_sel.end */
		swap(ps, pe);

	if (vc_sel.cons != vc) {
		clear_selection();
		vc_sel.cons = vc;
	}

	return vc_do_selection(vc, v->sel_mode, ps, pe);
}

int set_selection_kernel(struct tiocl_selection *v, struct tty_struct *tty)
{
	int ret;

	mutex_lock(&vc_sel.lock);
	console_lock();
	ret = vc_selection(vc_cons[fg_console].d, v, tty);
	console_unlock();
	mutex_unlock(&vc_sel.lock);

	return ret;
}
EXPORT_SYMBOL_GPL(set_selection_kernel);

/* Insert the contents of the selection buffer into the
 * queue of the tty associated with the current console.
 * Invoked by ioctl().
 *
 * Locking: called without locks. Calls the ldisc wrongly with
 * unsafe methods,
 */
int paste_selection(struct tty_struct *tty)
{
	struct vc_data *vc = tty->driver_data;
	int	pasted = 0;
	size_t count;
	struct  tty_ldisc *ld;
	DECLARE_WAITQUEUE(wait, current);
	int ret = 0;

	console_lock();
	poke_blanked_console();
	console_unlock();

	ld = tty_ldisc_ref_wait(tty);
	if (!ld)
		return -EIO;	/* ldisc was hung up */
	tty_buffer_lock_exclusive(&vc->port);

	add_wait_queue(&vc->paste_wait, &wait);
	mutex_lock(&vc_sel.lock);
	while (vc_sel.buffer && vc_sel.buf_len > pasted) {
		set_current_state(TASK_INTERRUPTIBLE);
		if (signal_pending(current)) {
			ret = -EINTR;
			break;
		}
		if (tty_throttled(tty)) {
			mutex_unlock(&vc_sel.lock);
			schedule();
			mutex_lock(&vc_sel.lock);
			continue;
		}
		__set_current_state(TASK_RUNNING);
		count = vc_sel.buf_len - pasted;
		count = tty_ldisc_receive_buf(ld, vc_sel.buffer + pasted, NULL,
					      count);
		pasted += count;
	}
	mutex_unlock(&vc_sel.lock);
	remove_wait_queue(&vc->paste_wait, &wait);
	__set_current_state(TASK_RUNNING);

	tty_buffer_unlock_exclusive(&vc->port);
	tty_ldisc_deref(ld);
	return ret;
}
EXPORT_SYMBOL_GPL(paste_selection);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
1da177e4 LT	3	* This module exports the functions:
1da177e4 LT	4	*
496124e5 OK	5	* 'int set_selection_user(struct tiocl_selection __user *,
	6	* struct tty_struct *)'
	7	* 'int set_selection_kernel(struct tiocl_selection , struct tty_struct )'
1da177e4 LT	8	* 'void clear_selection(void)'
1da177e4 LT	9	* 'int paste_selection(struct tty_struct *)'
a0b8a168	10	* 'int sel_loadlut(u32 __user *)'
1da177e4 LT	11	*
	12	* Now that /dev/vcs exists, most of this can disappear again.
	13	*/
	14
	15	#include <linux/module.h>
	16	#include <linux/tty.h>
	17	#include <linux/sched.h>
	18	#include <linux/mm.h>
07e6124a	19	#include <linux/mutex.h>
1da177e4 LT	20	#include <linux/slab.h>
	21	#include <linux/types.h>
	22
7c0f6ba6	23	#include <linux/uaccess.h>
1da177e4	24
759448f4	25	#include <linux/kbd_kern.h>
1da177e4 LT	26	#include <linux/vt_kern.h>
	27	#include <linux/consolemap.h>
	28	#include <linux/selection.h>
	29	#include <linux/tiocl.h>
	30	#include <linux/console.h>
a7c8d58c	31	#include <linux/tty_flip.h>
1da177e4	32
687bff0c JS	33	#include <linux/sched/signal.h>
687bff0c JS	34
1da177e4	35	/* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */
7985723d	36	#define is_space_on_vt(c) ((c) == ' ')
1da177e4	37
079c9534	38	/* FIXME: all this needs locking */
9256d09f JS	39	static struct vc_selection {
	40	struct mutex lock;
	41	struct vc_data cons; / must not be deallocated */
	42	char *buffer;
	43	unsigned int buf_len;
	44	volatile int start; /* cleared by clear_selection */
	45	int end;
	46	} vc_sel = {
	47	.lock = __MUTEX_INITIALIZER(vc_sel.lock),
	48	.start = -1,
	49	};
1da177e4 LT	50
	51	/* clear_selection, highlight and highlight_pointer can be called
	52	from interrupt (via scrollback/front) */
	53
	54	/* set reverse video on characters s-e of console with selection. */
	55	static inline void highlight(const int s, const int e)
	56	{
b8209f69	57	invert_screen(vc_sel.cons, s, e-s+2, true);
1da177e4 LT	58	}
	59
	60	/* use complementary color to show the pointer */
	61	static inline void highlight_pointer(const int where)
	62	{
9256d09f	63	complement_pos(vc_sel.cons, where);
1da177e4 LT	64	}
1da177e4 LT	65
9bfdc261	66	static u32
555b4ef7	67	sel_pos(int n, bool unicode)
1da177e4	68	{
555b4ef7	69	if (unicode)
9256d09f	70	return screen_glyph_unicode(vc_sel.cons, n / 2);
d9ebb906 JS	71	return inverse_translate(vc_sel.cons, screen_glyph(vc_sel.cons, n),
d9ebb906 JS	72	false);
1da177e4 LT	73	}
1da177e4 LT	74
5289475d	75	/**
60234365	76	* clear_selection - remove current selection
5289475d	77	*
60234365 JSS	78	* Remove the current selection highlight, if any from the console holding the
	79	* selection.
	80	*
	81	* Locking: The caller must hold the console lock.
5289475d AC	82	*/
	83	void clear_selection(void)
	84	{
1da177e4	85	highlight_pointer(-1); /* hide the pointer */
9256d09f JS	86	if (vc_sel.start != -1) {
	87	highlight(vc_sel.start, vc_sel.end);
	88	vc_sel.start = -1;
1da177e4 LT	89	}
1da177e4 LT	90	}
496124e5	91	EXPORT_SYMBOL_GPL(clear_selection);
1da177e4	92
d4c0c481	93	bool vc_is_sel(const struct vc_data *vc)
dce05aa6	94	{
9256d09f	95	return vc == vc_sel.cons;
dce05aa6 JS	96	}
dce05aa6 JS	97
1da177e4 LT	98	/*
1da177e4 LT	99	* User settable table: what characters are to be considered alphabetic?
7f1534e1	100	* 128 bits. Locked by the console lock.
1da177e4	101	*/
7f1534e1	102	static u32 inwordLut[]={
1da177e4	103	0x00000000, /* control chars */
7d6d44ae	104	0x03FFE000, /* digits and "-./" */
1da177e4 LT	105	0x87FFFFFE, /* uppercase and '_' */
1da177e4 LT	106	0x07FFFFFE, /* lowercase */
1da177e4 LT	107	};
1da177e4 LT	108
9bfdc261 AB	109	static inline int inword(const u32 c)
9bfdc261 AB	110	{
7f1534e1	111	return c > 0x7f \|\| (( inwordLut[c>>5] >> (c & 0x1F) ) & 1);
1da177e4 LT	112	}
1da177e4 LT	113
5289475d	114	/**
60234365 JSS	115	* sel_loadlut() - load the LUT table
60234365 JSS	116	* @lut: user table
5289475d	117	*
60234365 JSS	118	* Load the LUT table from user space. Make a temporary copy so a partial
60234365 JSS	119	* update doesn't make a mess.
d321cd13	120	*
60234365	121	* Locking: The console lock is acquired.
5289475d	122	*/
a0b8a168	123	int sel_loadlut(u32 __user *lut)
1da177e4	124	{
7f1534e1	125	u32 tmplut[ARRAY_SIZE(inwordLut)];
d321cd13	126
a0b8a168	127	if (copy_from_user(tmplut, lut, sizeof(inwordLut)))
5289475d	128	return -EFAULT;
d321cd13 JSS	129
d321cd13 JSS	130	console_lock();
7f1534e1	131	memcpy(inwordLut, tmplut, sizeof(inwordLut));
d321cd13 JSS	132	console_unlock();
d321cd13 JSS	133
5289475d	134	return 0;
1da177e4 LT	135	}
	136
	137	/* does screen address p correspond to character at LH/RH edge of screen? */
	138	static inline int atedge(const int p, int size_row)
	139	{
	140	return (!(p % size_row) \|\| !((p + 2) % size_row));
	141	}
	142
df155d2d AB	143	/* stores the char in UTF8 and returns the number of bytes used (1-4) */
df155d2d AB	144	static int store_utf8(u32 c, char *p)
759448f4 JE	145	{
	146	if (c < 0x80) {
	147	/* 0******* */
	148	p[0] = c;
	149	return 1;
	150	} else if (c < 0x800) {
	151	/* 110*** 10**** */
	152	p[0] = 0xc0 \| (c >> 6);
	153	p[1] = 0x80 \| (c & 0x3f);
	154	return 2;
df155d2d	155	} else if (c < 0x10000) {
759448f4 JE	156	/* 1110** 10** 10**** */
	157	p[0] = 0xe0 \| (c >> 12);
	158	p[1] = 0x80 \| ((c >> 6) & 0x3f);
	159	p[2] = 0x80 \| (c & 0x3f);
	160	return 3;
df155d2d AB	161	} else if (c < 0x110000) {
	162	/* 11110* 10** 10** 10**** */
	163	p[0] = 0xf0 \| (c >> 18);
	164	p[1] = 0x80 \| ((c >> 12) & 0x3f);
	165	p[2] = 0x80 \| ((c >> 6) & 0x3f);
	166	p[3] = 0x80 \| (c & 0x3f);
	167	return 4;
	168	} else {
	169	/* outside Unicode, replace with U+FFFD */
	170	p[0] = 0xef;
	171	p[1] = 0xbf;
	172	p[2] = 0xbd;
	173	return 3;
	174	}
759448f4 JE	175	}
759448f4 JE	176
5289475d	177	/**
60234365 JSS	178	* set_selection_user - set the current selection.
	179	* @sel: user selection info
	180	* @tty: the console tty
5289475d	181	*
60234365	182	* Invoked by the ioctl handle for the vt layer.
5289475d	183	*
60234365 JSS	184	* Locking: The entire selection process is managed under the console_lock.
60234365 JSS	185	* It's a lot under the lock but its hardly a performance path.
5289475d	186	*/
496124e5 OK	187	int set_selection_user(const struct tiocl_selection __user *sel,
	188	struct tty_struct *tty)
	189	{
	190	struct tiocl_selection v;
	191
	192	if (copy_from_user(&v, sel, sizeof(*sel)))
	193	return -EFAULT;
	194
	195	return set_selection_kernel(&v, tty);
	196	}
	197
8fd31e69 JS	198	static int vc_selection_store_chars(struct vc_data *vc, bool unicode)
	199	{
	200	char bp, obp;
	201	unsigned int i;
	202
	203	/* Allocate a new buffer before freeing the old one ... */
	204	/* chars can take up to 4 bytes with unicode */
	205	bp = kmalloc_array((vc_sel.end - vc_sel.start) / 2 + 1, unicode ? 4 : 1,
44c413d9	206	GFP_KERNEL \| __GFP_NOWARN);
8fd31e69 JS	207	if (!bp) {
	208	printk(KERN_WARNING "selection: kmalloc() failed\n");
	209	clear_selection();
	210	return -ENOMEM;
	211	}
	212	kfree(vc_sel.buffer);
	213	vc_sel.buffer = bp;
	214
	215	obp = bp;
	216	for (i = vc_sel.start; i <= vc_sel.end; i += 2) {
	217	u32 c = sel_pos(i, unicode);
	218	if (unicode)
	219	bp += store_utf8(c, bp);
	220	else
	221	*bp++ = c;
7985723d	222	if (!is_space_on_vt(c))
8fd31e69 JS	223	obp = bp;
	224	if (!((i + 2) % vc->vc_size_row)) {
	225	/* strip trailing blanks from line and add newline,
	226	unless non-space at end of line. */
	227	if (obp != bp) {
	228	bp = obp;
	229	*bp++ = '\r';
	230	}
	231	obp = bp;
	232	}
	233	}
	234	vc_sel.buf_len = bp - vc_sel.buffer;
	235
	236	return 0;
	237	}
	238
9ba4ddbc JS	239	static int vc_do_selection(struct vc_data *vc, unsigned short mode, int ps,
9ba4ddbc JS	240	int pe)
1da177e4	241	{
2a479aa8	242	int new_sel_start, new_sel_end, spc;
9ba4ddbc	243	bool unicode = vt_do_kdgkbmode(fg_console) == K_UNICODE;
1da177e4	244
9ba4ddbc	245	switch (mode) {
bc80932c JS	246	case TIOCL_SELCHAR: /* character-by-character selection */
	247	new_sel_start = ps;
	248	new_sel_end = pe;
	249	break;
	250	case TIOCL_SELWORD: /* word-by-word selection */
7985723d	251	spc = is_space_on_vt(sel_pos(ps, unicode));
bc80932c	252	for (new_sel_start = ps; ; ps -= 2) {
7985723d	253	if ((spc && !is_space_on_vt(sel_pos(ps, unicode))) \|\|
bc80932c JS	254	(!spc && !inword(sel_pos(ps, unicode))))
bc80932c JS	255	break;
1da177e4	256	new_sel_start = ps;
bc80932c JS	257	if (!(ps % vc->vc_size_row))
	258	break;
	259	}
	260
7985723d	261	spc = is_space_on_vt(sel_pos(pe, unicode));
bc80932c	262	for (new_sel_end = pe; ; pe += 2) {
7985723d	263	if ((spc && !is_space_on_vt(sel_pos(pe, unicode))) \|\|
bc80932c JS	264	(!spc && !inword(sel_pos(pe, unicode))))
bc80932c JS	265	break;
1da177e4	266	new_sel_end = pe;
bc80932c JS	267	if (!((pe + 2) % vc->vc_size_row))
	268	break;
	269	}
	270	break;
	271	case TIOCL_SELLINE: /* line-by-line selection */
f0e8e3da JS	272	new_sel_start = rounddown(ps, vc->vc_size_row);
	273	new_sel_end = rounddown(pe, vc->vc_size_row) +
	274	vc->vc_size_row - 2;
bc80932c JS	275	break;
	276	case TIOCL_SELPOINTER:
	277	highlight_pointer(pe);
cb05c6c8	278	return 0;
bc80932c	279	default:
cb05c6c8	280	return -EINVAL;
1da177e4 LT	281	}
	282
	283	/* remove the pointer */
	284	highlight_pointer(-1);
	285
	286	/* select to end of line if on trailing space */
	287	if (new_sel_end > new_sel_start &&
	288	!atedge(new_sel_end, vc->vc_size_row) &&
7985723d	289	is_space_on_vt(sel_pos(new_sel_end, unicode))) {
1da177e4	290	for (pe = new_sel_end + 2; ; pe += 2)
7985723d	291	if (!is_space_on_vt(sel_pos(pe, unicode)) \|\|
1da177e4 LT	292	atedge(pe, vc->vc_size_row))
1da177e4 LT	293	break;
7985723d	294	if (is_space_on_vt(sel_pos(pe, unicode)))
1da177e4 LT	295	new_sel_end = pe;
1da177e4 LT	296	}
9256d09f	297	if (vc_sel.start == -1) /* no current selection */
1da177e4	298	highlight(new_sel_start, new_sel_end);
9256d09f	299	else if (new_sel_start == vc_sel.start)
1da177e4	300	{
9256d09f	301	if (new_sel_end == vc_sel.end) /* no action required */
e8c75a30	302	return 0;
9256d09f JS	303	else if (new_sel_end > vc_sel.end) /* extend to right */
9256d09f JS	304	highlight(vc_sel.end + 2, new_sel_end);
1da177e4	305	else /* contract from right */
9256d09f	306	highlight(new_sel_end + 2, vc_sel.end);
1da177e4	307	}
9256d09f	308	else if (new_sel_end == vc_sel.end)
1da177e4	309	{
9256d09f JS	310	if (new_sel_start < vc_sel.start) /* extend to left */
9256d09f JS	311	highlight(new_sel_start, vc_sel.start - 2);
1da177e4	312	else /* contract from left */
9256d09f	313	highlight(vc_sel.start, new_sel_start - 2);
1da177e4 LT	314	}
	315	else /* some other case; start selection from scratch */
	316	{
	317	clear_selection();
	318	highlight(new_sel_start, new_sel_end);
	319	}
9256d09f JS	320	vc_sel.start = new_sel_start;
9256d09f JS	321	vc_sel.end = new_sel_end;
1da177e4	322
8fd31e69	323	return vc_selection_store_chars(vc, unicode);
1da177e4	324	}
4b70dd57	325
9ba4ddbc JS	326	static int vc_selection(struct vc_data vc, struct tiocl_selection v,
	327	struct tty_struct *tty)
	328	{
	329	int ps, pe;
	330
	331	poke_blanked_console();
	332
	333	if (v->sel_mode == TIOCL_SELCLEAR) {
	334	/* useful for screendump without selection highlights */
	335	clear_selection();
	336	return 0;
	337	}
	338
	339	v->xs = min_t(u16, v->xs - 1, vc->vc_cols - 1);
	340	v->ys = min_t(u16, v->ys - 1, vc->vc_rows - 1);
	341	v->xe = min_t(u16, v->xe - 1, vc->vc_cols - 1);
	342	v->ye = min_t(u16, v->ye - 1, vc->vc_rows - 1);
	343
	344	if (mouse_reporting() && (v->sel_mode & TIOCL_SELMOUSEREPORT)) {
	345	mouse_report(tty, v->sel_mode & TIOCL_SELBUTTONMASK, v->xs,
	346	v->ys);
	347	return 0;
	348	}
	349
	350	ps = v->ys * vc->vc_size_row + (v->xs << 1);
	351	pe = v->ye * vc->vc_size_row + (v->xe << 1);
	352	if (ps > pe) /* make vc_sel.start <= vc_sel.end */
	353	swap(ps, pe);
	354
	355	if (vc_sel.cons != vc) {
	356	clear_selection();
	357	vc_sel.cons = vc;
	358	}
	359
	360	return vc_do_selection(vc, v->sel_mode, ps, pe);
	361	}
	362
4b70dd57 JS	363	int set_selection_kernel(struct tiocl_selection v, struct tty_struct tty)
	364	{
	365	int ret;
	366
cb05c6c8	367	mutex_lock(&vc_sel.lock);
4b70dd57	368	console_lock();
9ba4ddbc	369	ret = vc_selection(vc_cons[fg_console].d, v, tty);
4b70dd57	370	console_unlock();
9256d09f	371	mutex_unlock(&vc_sel.lock);
4b70dd57	372
07e6124a	373	return ret;
1da177e4	374	}
496124e5	375	EXPORT_SYMBOL_GPL(set_selection_kernel);
1da177e4 LT	376
	377	/* Insert the contents of the selection buffer into the
	378	* queue of the tty associated with the current console.
	379	* Invoked by ioctl().
906cbe13	380	*
20f62579 AC	381	* Locking: called without locks. Calls the ldisc wrongly with
20f62579 AC	382	* unsafe methods,
1da177e4 LT	383	*/
	384	int paste_selection(struct tty_struct *tty)
	385	{
c9f19e96	386	struct vc_data *vc = tty->driver_data;
33f0f88f	387	int pasted = 0;
8d9526f9	388	size_t count;
1da177e4 LT	389	struct tty_ldisc *ld;
1da177e4 LT	390	DECLARE_WAITQUEUE(wait, current);
687bff0c	391	int ret = 0;
1da177e4	392
ac751efa	393	console_lock();
1da177e4	394	poke_blanked_console();
ac751efa	395	console_unlock();
1da177e4	396
7ee00fdb	397	ld = tty_ldisc_ref_wait(tty);
e55afd11 PH	398	if (!ld)
e55afd11 PH	399	return -EIO; /* ldisc was hung up */
a7c8d58c	400	tty_buffer_lock_exclusive(&vc->port);
60af22d2	401
1da177e4	402	add_wait_queue(&vc->paste_wait, &wait);
9256d09f JS	403	mutex_lock(&vc_sel.lock);
9256d09f JS	404	while (vc_sel.buffer && vc_sel.buf_len > pasted) {
1da177e4	405	set_current_state(TASK_INTERRUPTIBLE);
687bff0c JS	406	if (signal_pending(current)) {
	407	ret = -EINTR;
	408	break;
	409	}
97ef38b8	410	if (tty_throttled(tty)) {
9256d09f	411	mutex_unlock(&vc_sel.lock);
1da177e4	412	schedule();
9256d09f	413	mutex_lock(&vc_sel.lock);
1da177e4 LT	414	continue;
1da177e4 LT	415	}
61e86cc9	416	__set_current_state(TASK_RUNNING);
9256d09f JS	417	count = vc_sel.buf_len - pasted;
9256d09f JS	418	count = tty_ldisc_receive_buf(ld, vc_sel.buffer + pasted, NULL,
24a89d1c	419	count);
1da177e4 LT	420	pasted += count;
1da177e4 LT	421	}
9256d09f	422	mutex_unlock(&vc_sel.lock);
1da177e4	423	remove_wait_queue(&vc->paste_wait, &wait);
cc0a8fbb	424	__set_current_state(TASK_RUNNING);
1da177e4	425
a7c8d58c	426	tty_buffer_unlock_exclusive(&vc->port);
1da177e4	427	tty_ldisc_deref(ld);
687bff0c	428	return ret;
1da177e4	429	}
496124e5	430	EXPORT_SYMBOL_GPL(paste_selection);