[deliverable/linux.git] / arch / um / drivers / chan_user.c

/*
 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
 * Licensed under the GPL
 */

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sched.h>
#include <signal.h>
#include <termios.h>
#include <sys/ioctl.h>
#include "chan_user.h"
#include "os.h"
#include "um_malloc.h"
#include "user.h"

void generic_close(int fd, void *unused)
{
	close(fd);
}

int generic_read(int fd, char *c_out, void *unused)
{
	int n;

	n = read(fd, c_out, sizeof(*c_out));
	if (n > 0)
		return n;
	else if (errno == EAGAIN)
		return 0;
	else if (n == 0)
		return -EIO;
	return -errno;
}

/* XXX Trivial wrapper around write */

int generic_write(int fd, const char *buf, int n, void *unused)
{
	int err;

	err = write(fd, buf, n);
	if (err > 0)
		return err;
	else if (errno == EAGAIN)
		return 0;
	else if (err == 0)
		return -EIO;
	return -errno;
}

int generic_window_size(int fd, void *unused, unsigned short *rows_out,
			unsigned short *cols_out)
{
	struct winsize size;
	int ret;

	if (ioctl(fd, TIOCGWINSZ, &size) < 0)
		return -errno;

	ret = ((*rows_out != size.ws_row) || (*cols_out != size.ws_col));

	*rows_out = size.ws_row;
	*cols_out = size.ws_col;

	return ret;
}

void generic_free(void *data)
{
	kfree(data);
}

int generic_console_write(int fd, const char *buf, int n)
{
	struct termios save, new;
	int err;

	if (isatty(fd)) {
		CATCH_EINTR(err = tcgetattr(fd, &save));
		if (err)
			goto error;
		new = save;
		/*
		 * The terminal becomes a bit less raw, to handle \n also as
		 * "Carriage Return", not only as "New Line". Otherwise, the new
		 * line won't start at the first column.
		 */
		new.c_oflag |= OPOST;
		CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &new));
		if (err)
			goto error;
	}
	err = generic_write(fd, buf, n, NULL);
	/*
	 * Restore raw mode, in any case; we *must* ignore any error apart
	 * EINTR, except for debug.
	 */
	if (isatty(fd))
		CATCH_EINTR(tcsetattr(fd, TCSAFLUSH, &save));
	return err;
error:
	return -errno;
}

/*
 * UML SIGWINCH handling
 *
 * The point of this is to handle SIGWINCH on consoles which have host
 * ttys and relay them inside UML to whatever might be running on the
 * console and cares about the window size (since SIGWINCH notifies
 * about terminal size changes).
 *
 * So, we have a separate thread for each host tty attached to a UML
 * device (side-issue - I'm annoyed that one thread can't have
 * multiple controlling ttys for the purpose of handling SIGWINCH, but
 * I imagine there are other reasons that doesn't make any sense).
 *
 * SIGWINCH can't be received synchronously, so you have to set up to
 * receive it as a signal.  That being the case, if you are going to
 * wait for it, it is convenient to sit in sigsuspend() and wait for
 * the signal to bounce you out of it (see below for how we make sure
 * to exit only on SIGWINCH).
 */

static void winch_handler(int sig)
{
}

struct winch_data {
	int pty_fd;
	int pipe_fd;
};

static int winch_thread(void *arg)
{
	struct winch_data *data = arg;
	sigset_t sigs;
	int pty_fd, pipe_fd;
	int count;
	char c = 1;

	pty_fd = data->pty_fd;
	pipe_fd = data->pipe_fd;
	count = write(pipe_fd, &c, sizeof(c));
	if (count != sizeof(c))
		printk(UM_KERN_ERR "winch_thread : failed to write "
		       "synchronization byte, err = %d\n", -count);

	/*
	 * We are not using SIG_IGN on purpose, so don't fix it as I thought to
	 * do! If using SIG_IGN, the sigsuspend() call below would not stop on
	 * SIGWINCH.
	 */

	signal(SIGWINCH, winch_handler);
	sigfillset(&sigs);
	/* Block all signals possible. */
	if (sigprocmask(SIG_SETMASK, &sigs, NULL) < 0) {
		printk(UM_KERN_ERR "winch_thread : sigprocmask failed, "
		       "errno = %d\n", errno);
		exit(1);
	}
	/* In sigsuspend(), block anything else than SIGWINCH. */
	sigdelset(&sigs, SIGWINCH);

	if (setsid() < 0) {
		printk(UM_KERN_ERR "winch_thread : setsid failed, errno = %d\n",
		       errno);
		exit(1);
	}

	if (ioctl(pty_fd, TIOCSCTTY, 0) < 0) {
		printk(UM_KERN_ERR "winch_thread : TIOCSCTTY failed on "
		       "fd %d err = %d\n", pty_fd, errno);
		exit(1);
	}

	if (tcsetpgrp(pty_fd, os_getpid()) < 0) {
		printk(UM_KERN_ERR "winch_thread : tcsetpgrp failed on "
		       "fd %d err = %d\n", pty_fd, errno);
		exit(1);
	}

	/*
	 * These are synchronization calls between various UML threads on the
	 * host - since they are not different kernel threads, we cannot use
	 * kernel semaphores. We don't use SysV semaphores because they are
	 * persistent.
	 */
	count = read(pipe_fd, &c, sizeof(c));
	if (count != sizeof(c))
		printk(UM_KERN_ERR "winch_thread : failed to read "
		       "synchronization byte, err = %d\n", errno);

	while(1) {
		/*
		 * This will be interrupted by SIGWINCH only, since
		 * other signals are blocked.
		 */
		sigsuspend(&sigs);

		count = write(pipe_fd, &c, sizeof(c));
		if (count != sizeof(c))
			printk(UM_KERN_ERR "winch_thread : write failed, "
			       "err = %d\n", errno);
	}
}

static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out,
		       unsigned long *stack_out)
{
	struct winch_data data;
	int fds[2], n, err;
	char c;

	err = os_pipe(fds, 1, 1);
	if (err < 0) {
		printk(UM_KERN_ERR "winch_tramp : os_pipe failed, err = %d\n",
		       -err);
		goto out;
	}

	data = ((struct winch_data) { .pty_fd 		= fd,
				      .pipe_fd 		= fds[1] } );
	/*
	 * CLONE_FILES so this thread doesn't hold open files which are open
	 * now, but later closed in a different thread.  This is a
	 * problem with /dev/net/tun, which if held open by this
	 * thread, prevents the TUN/TAP device from being reused.
	 */
	err = run_helper_thread(winch_thread, &data, CLONE_FILES, stack_out);
	if (err < 0) {
		printk(UM_KERN_ERR "fork of winch_thread failed - errno = %d\n",
		       -err);
		goto out_close;
	}

	*fd_out = fds[0];
	n = read(fds[0], &c, sizeof(c));
	if (n != sizeof(c)) {
		printk(UM_KERN_ERR "winch_tramp : failed to read "
		       "synchronization byte\n");
		printk(UM_KERN_ERR "read failed, err = %d\n", errno);
		printk(UM_KERN_ERR "fd %d will not support SIGWINCH\n", fd);
		err = -EINVAL;
		goto out_close;
	}

	if (os_set_fd_block(*fd_out, 0)) {
		printk(UM_KERN_ERR "winch_tramp: failed to set thread_fd "
		       "non-blocking.\n");
		goto out_close;
	}

	return err;

 out_close:
	close(fds[1]);
	close(fds[0]);
 out:
	return err;
}

void register_winch(int fd, struct tty_struct *tty)
{
	unsigned long stack;
	int pid, thread, count, thread_fd = -1;
	char c = 1;

	if (!isatty(fd))
		return;

	pid = tcgetpgrp(fd);
	if (!is_skas_winch(pid, fd, tty) && (pid == -1)) {
		thread = winch_tramp(fd, tty, &thread_fd, &stack);
		if (thread < 0)
			return;

		register_winch_irq(thread_fd, fd, thread, tty, stack);

		count = write(thread_fd, &c, sizeof(c));
		if (count != sizeof(c))
			printk(UM_KERN_ERR "register_winch : failed to write "
			       "synchronization byte, err = %d\n", errno);
	}
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2000 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include <stdlib.h>
	7	#include <unistd.h>
	8	#include <errno.h>
	9	#include <sched.h>
	10	#include <signal.h>
	11	#include <termios.h>
	12	#include <sys/ioctl.h>
	13	#include "chan_user.h"
	14	#include "os.h"
	15	#include "um_malloc.h"
	16	#include "user.h"
	17
	18	void generic_close(int fd, void *unused)
	19	{
	20	close(fd);
	21	}
	22
	23	int generic_read(int fd, char c_out, void unused)
	24	{
	25	int n;
	26
	27	n = read(fd, c_out, sizeof(*c_out));
	28	if (n > 0)
	29	return n;
	30	else if (errno == EAGAIN)
	31	return 0;
	32	else if (n == 0)
	33	return -EIO;
	34	return -errno;
	35	}
	36
	37	/* XXX Trivial wrapper around write */
	38
	39	int generic_write(int fd, const char buf, int n, void unused)
	40	{
	41	int err;
	42
	43	err = write(fd, buf, n);
	44	if (err > 0)
	45	return err;
	46	else if (errno == EAGAIN)
	47	return 0;
	48	else if (err == 0)
	49	return -EIO;
	50	return -errno;
	51	}
	52
	53	int generic_window_size(int fd, void unused, unsigned short rows_out,
	54	unsigned short *cols_out)
	55	{
	56	struct winsize size;
	57	int ret;
	58
	59	if (ioctl(fd, TIOCGWINSZ, &size) < 0)
	60	return -errno;
	61
	62	ret = ((rows_out != size.ws_row) \|\| (cols_out != size.ws_col));
	63
	64	*rows_out = size.ws_row;
	65	*cols_out = size.ws_col;
	66
	67	return ret;
	68	}
	69
	70	void generic_free(void *data)
	71	{
	72	kfree(data);
	73	}
	74
	75	int generic_console_write(int fd, const char *buf, int n)
	76	{
	77	struct termios save, new;
	78	int err;
	79
	80	if (isatty(fd)) {
	81	CATCH_EINTR(err = tcgetattr(fd, &save));
	82	if (err)
	83	goto error;
	84	new = save;
	85	/*
	86	* The terminal becomes a bit less raw, to handle \n also as
	87	* "Carriage Return", not only as "New Line". Otherwise, the new
	88	* line won't start at the first column.
	89	*/
	90	new.c_oflag \|= OPOST;
	91	CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &new));
	92	if (err)
	93	goto error;
	94	}
	95	err = generic_write(fd, buf, n, NULL);
	96	/*
	97	* Restore raw mode, in any case; we must ignore any error apart
	98	* EINTR, except for debug.
	99	*/
	100	if (isatty(fd))
	101	CATCH_EINTR(tcsetattr(fd, TCSAFLUSH, &save));
	102	return err;
	103	error:
	104	return -errno;
	105	}
	106
	107	/*
	108	* UML SIGWINCH handling
	109	*
	110	* The point of this is to handle SIGWINCH on consoles which have host
	111	* ttys and relay them inside UML to whatever might be running on the
	112	* console and cares about the window size (since SIGWINCH notifies
	113	* about terminal size changes).
	114	*
	115	* So, we have a separate thread for each host tty attached to a UML
	116	* device (side-issue - I'm annoyed that one thread can't have
	117	* multiple controlling ttys for the purpose of handling SIGWINCH, but
	118	* I imagine there are other reasons that doesn't make any sense).
	119	*
	120	* SIGWINCH can't be received synchronously, so you have to set up to
	121	* receive it as a signal. That being the case, if you are going to
	122	* wait for it, it is convenient to sit in sigsuspend() and wait for
	123	* the signal to bounce you out of it (see below for how we make sure
	124	* to exit only on SIGWINCH).
	125	*/
	126
	127	static void winch_handler(int sig)
	128	{
	129	}
	130
	131	struct winch_data {
	132	int pty_fd;
	133	int pipe_fd;
	134	};
	135
	136	static int winch_thread(void *arg)
	137	{
	138	struct winch_data *data = arg;
	139	sigset_t sigs;
	140	int pty_fd, pipe_fd;
	141	int count;
	142	char c = 1;
	143
	144	pty_fd = data->pty_fd;
	145	pipe_fd = data->pipe_fd;
	146	count = write(pipe_fd, &c, sizeof(c));
	147	if (count != sizeof(c))
	148	printk(UM_KERN_ERR "winch_thread : failed to write "
	149	"synchronization byte, err = %d\n", -count);
	150
	151	/*
	152	* We are not using SIG_IGN on purpose, so don't fix it as I thought to
	153	* do! If using SIG_IGN, the sigsuspend() call below would not stop on
	154	* SIGWINCH.
	155	*/
	156
	157	signal(SIGWINCH, winch_handler);
	158	sigfillset(&sigs);
	159	/* Block all signals possible. */
	160	if (sigprocmask(SIG_SETMASK, &sigs, NULL) < 0) {
	161	printk(UM_KERN_ERR "winch_thread : sigprocmask failed, "
	162	"errno = %d\n", errno);
	163	exit(1);
	164	}
	165	/* In sigsuspend(), block anything else than SIGWINCH. */
	166	sigdelset(&sigs, SIGWINCH);
	167
	168	if (setsid() < 0) {
	169	printk(UM_KERN_ERR "winch_thread : setsid failed, errno = %d\n",
	170	errno);
	171	exit(1);
	172	}
	173
	174	if (ioctl(pty_fd, TIOCSCTTY, 0) < 0) {
	175	printk(UM_KERN_ERR "winch_thread : TIOCSCTTY failed on "
	176	"fd %d err = %d\n", pty_fd, errno);
	177	exit(1);
	178	}
	179
	180	if (tcsetpgrp(pty_fd, os_getpid()) < 0) {
	181	printk(UM_KERN_ERR "winch_thread : tcsetpgrp failed on "
	182	"fd %d err = %d\n", pty_fd, errno);
	183	exit(1);
	184	}
	185
	186	/*
	187	* These are synchronization calls between various UML threads on the
	188	* host - since they are not different kernel threads, we cannot use
	189	* kernel semaphores. We don't use SysV semaphores because they are
	190	* persistent.
	191	*/
	192	count = read(pipe_fd, &c, sizeof(c));
	193	if (count != sizeof(c))
	194	printk(UM_KERN_ERR "winch_thread : failed to read "
	195	"synchronization byte, err = %d\n", errno);
	196
	197	while(1) {
	198	/*
	199	* This will be interrupted by SIGWINCH only, since
	200	* other signals are blocked.
	201	*/
	202	sigsuspend(&sigs);
	203
	204	count = write(pipe_fd, &c, sizeof(c));
	205	if (count != sizeof(c))
	206	printk(UM_KERN_ERR "winch_thread : write failed, "
	207	"err = %d\n", errno);
	208	}
	209	}
	210
	211	static int winch_tramp(int fd, struct tty_struct tty, int fd_out,
	212	unsigned long *stack_out)
	213	{
	214	struct winch_data data;
	215	int fds[2], n, err;
	216	char c;
	217
	218	err = os_pipe(fds, 1, 1);
	219	if (err < 0) {
	220	printk(UM_KERN_ERR "winch_tramp : os_pipe failed, err = %d\n",
	221	-err);
	222	goto out;
	223	}
	224
	225	data = ((struct winch_data) { .pty_fd = fd,
	226	.pipe_fd = fds[1] } );
	227	/*
	228	* CLONE_FILES so this thread doesn't hold open files which are open
	229	* now, but later closed in a different thread. This is a
	230	* problem with /dev/net/tun, which if held open by this
	231	* thread, prevents the TUN/TAP device from being reused.
	232	*/
	233	err = run_helper_thread(winch_thread, &data, CLONE_FILES, stack_out);
	234	if (err < 0) {
	235	printk(UM_KERN_ERR "fork of winch_thread failed - errno = %d\n",
	236	-err);
	237	goto out_close;
	238	}
	239
	240	*fd_out = fds[0];
	241	n = read(fds[0], &c, sizeof(c));
	242	if (n != sizeof(c)) {
	243	printk(UM_KERN_ERR "winch_tramp : failed to read "
	244	"synchronization byte\n");
	245	printk(UM_KERN_ERR "read failed, err = %d\n", errno);
	246	printk(UM_KERN_ERR "fd %d will not support SIGWINCH\n", fd);
	247	err = -EINVAL;
	248	goto out_close;
	249	}
	250
	251	if (os_set_fd_block(*fd_out, 0)) {
	252	printk(UM_KERN_ERR "winch_tramp: failed to set thread_fd "
	253	"non-blocking.\n");
	254	goto out_close;
	255	}
	256
	257	return err;
	258
	259	out_close:
	260	close(fds[1]);
	261	close(fds[0]);
	262	out:
	263	return err;
	264	}
	265
	266	void register_winch(int fd, struct tty_struct *tty)
	267	{
	268	unsigned long stack;
	269	int pid, thread, count, thread_fd = -1;
	270	char c = 1;
	271
	272	if (!isatty(fd))
	273	return;
	274
	275	pid = tcgetpgrp(fd);
	276	if (!is_skas_winch(pid, fd, tty) && (pid == -1)) {
	277	thread = winch_tramp(fd, tty, &thread_fd, &stack);
	278	if (thread < 0)
	279	return;
	280
	281	register_winch_irq(thread_fd, fd, thread, tty, stack);
	282
	283	count = write(thread_fd, &c, sizeof(c));
	284	if (count != sizeof(c))
	285	printk(UM_KERN_ERR "register_winch : failed to write "
	286	"synchronization byte, err = %d\n", errno);
	287	}
	288	}