[deliverable/linux.git] / arch / um / os-Linux / sigio.c

/*
 * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 */

#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <pty.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sched.h>
#include <sys/socket.h>
#include <sys/poll.h>
#include "init.h"
#include "user.h"
#include "kern_util.h"
#include "sigio.h"
#include "os.h"
#include "um_malloc.h"
#include "init.h"

/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
 * exitcall.
 */
static int write_sigio_pid = -1;
static unsigned long write_sigio_stack;

/* These arrays are initialized before the sigio thread is started, and
 * the descriptors closed after it is killed.  So, it can't see them change.
 * On the UML side, they are changed under the sigio_lock.
 */
#define SIGIO_FDS_INIT {-1, -1}

static int write_sigio_fds[2] = SIGIO_FDS_INIT;
static int sigio_private[2] = SIGIO_FDS_INIT;

struct pollfds {
	struct pollfd *poll;
	int size;
	int used;
};

/* Protected by sigio_lock().  Used by the sigio thread, but the UML thread
 * synchronizes with it.
 */
static struct pollfds current_poll;
static struct pollfds next_poll;
static struct pollfds all_sigio_fds;

static int write_sigio_thread(void *unused)
{
	struct pollfds *fds, tmp;
	struct pollfd *p;
	int i, n, respond_fd;
	char c;

        signal(SIGWINCH, SIG_IGN);
	fds = &current_poll;
	while(1){
		n = poll(fds->poll, fds->used, -1);
		if(n < 0){
			if(errno == EINTR) continue;
			printk("write_sigio_thread : poll returned %d, "
			       "errno = %d\n", n, errno);
		}
		for(i = 0; i < fds->used; i++){
			p = &fds->poll[i];
			if(p->revents == 0) continue;
			if(p->fd == sigio_private[1]){
				CATCH_EINTR(n = read(sigio_private[1], &c,
						     sizeof(c)));
				if(n != sizeof(c))
					printk("write_sigio_thread : "
					       "read on socket failed, "
					       "err = %d\n", errno);
				tmp = current_poll;
				current_poll = next_poll;
				next_poll = tmp;
				respond_fd = sigio_private[1];
			}
			else {
				respond_fd = write_sigio_fds[1];
				fds->used--;
				memmove(&fds->poll[i], &fds->poll[i + 1],
					(fds->used - i) * sizeof(*fds->poll));
			}

			CATCH_EINTR(n = write(respond_fd, &c, sizeof(c)));
			if(n != sizeof(c))
				printk("write_sigio_thread : write on socket "
				       "failed, err = %d\n", errno);
		}
	}

	return 0;
}

static int need_poll(struct pollfds *polls, int n)
{
	struct pollfd *new;

	if(n <= polls->size)
		return 0;

	new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC);
	if(new == NULL){
		printk("need_poll : failed to allocate new pollfds\n");
		return -ENOMEM;
	}

	memcpy(new, polls->poll, polls->used * sizeof(struct pollfd));
	kfree(polls->poll);

	polls->poll = new;
	polls->size = n;
	return 0;
}

/* Must be called with sigio_lock held, because it's needed by the marked
 * critical section.
 */
static void update_thread(void)
{
	unsigned long flags;
	int n;
	char c;

	flags = set_signals(0);
	n = write(sigio_private[0], &c, sizeof(c));
	if(n != sizeof(c)){
		printk("update_thread : write failed, err = %d\n", errno);
		goto fail;
	}

	CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c)));
	if(n != sizeof(c)){
		printk("update_thread : read failed, err = %d\n", errno);
		goto fail;
	}

	set_signals(flags);
	return;
 fail:
	/* Critical section start */
	if (write_sigio_pid != -1) {
		os_kill_process(write_sigio_pid, 1);
		free_stack(write_sigio_stack, 0);
	}
	write_sigio_pid = -1;
	close(sigio_private[0]);
	close(sigio_private[1]);
	close(write_sigio_fds[0]);
	close(write_sigio_fds[1]);
	/* Critical section end */
	set_signals(flags);
}

int add_sigio_fd(int fd)
{
	struct pollfd *p;
	int err = 0, i, n;

	sigio_lock();
	for(i = 0; i < all_sigio_fds.used; i++){
		if(all_sigio_fds.poll[i].fd == fd)
			break;
	}
	if(i == all_sigio_fds.used)
		goto out;

	p = &all_sigio_fds.poll[i];

	for(i = 0; i < current_poll.used; i++){
		if(current_poll.poll[i].fd == fd)
			goto out;
	}

	n = current_poll.used;
	err = need_poll(&next_poll, n + 1);
	if(err)
		goto out;

	memcpy(next_poll.poll, current_poll.poll,
	       current_poll.used * sizeof(struct pollfd));
	next_poll.poll[n] = *p;
	next_poll.used = n + 1;
	update_thread();
 out:
	sigio_unlock();
	return err;
}

int ignore_sigio_fd(int fd)
{
	struct pollfd *p;
	int err = 0, i, n = 0;

	/* This is called from exitcalls elsewhere in UML - if
	 * sigio_cleanup has already run, then update_thread will hang
	 * or fail because the thread is no longer running.
	 */
	if(write_sigio_pid == -1)
		return -EIO;

	sigio_lock();
	for(i = 0; i < current_poll.used; i++){
		if(current_poll.poll[i].fd == fd) break;
	}
	if(i == current_poll.used)
		goto out;

	err = need_poll(&next_poll, current_poll.used - 1);
	if(err)
		goto out;

	for(i = 0; i < current_poll.used; i++){
		p = &current_poll.poll[i];
		if(p->fd != fd)
			next_poll.poll[n++] = *p;
	}
	next_poll.used = current_poll.used - 1;

	update_thread();
 out:
	sigio_unlock();
	return err;
}

static struct pollfd *setup_initial_poll(int fd)
{
	struct pollfd *p;

	p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL);
	if (p == NULL) {
		printk("setup_initial_poll : failed to allocate poll\n");
		return NULL;
	}
	*p = ((struct pollfd) { .fd		= fd,
				.events 	= POLLIN,
				.revents 	= 0 });
	return p;
}

static void write_sigio_workaround(void)
{
	struct pollfd *p;
	int err;
	int l_write_sigio_fds[2];
	int l_sigio_private[2];
	int l_write_sigio_pid;

	/* We call this *tons* of times - and most ones we must just fail. */
	sigio_lock();
	l_write_sigio_pid = write_sigio_pid;
	sigio_unlock();

	if (l_write_sigio_pid != -1)
		return;

	err = os_pipe(l_write_sigio_fds, 1, 1);
	if(err < 0){
		printk("write_sigio_workaround - os_pipe 1 failed, "
		       "err = %d\n", -err);
		return;
	}
	err = os_pipe(l_sigio_private, 1, 1);
	if(err < 0){
		printk("write_sigio_workaround - os_pipe 2 failed, "
		       "err = %d\n", -err);
		goto out_close1;
	}

	p = setup_initial_poll(l_sigio_private[1]);
	if(!p)
		goto out_close2;

	sigio_lock();

	/* Did we race? Don't try to optimize this, please, it's not so likely
	 * to happen, and no more than once at the boot. */
	if(write_sigio_pid != -1)
		goto out_free;

	current_poll = ((struct pollfds) { .poll 	= p,
					   .used 	= 1,
					   .size 	= 1 });

	if (write_sigio_irq(l_write_sigio_fds[0]))
		goto out_clear_poll;

	memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
	memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));

	write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
					    CLONE_FILES | CLONE_VM,
					    &write_sigio_stack);

	if (write_sigio_pid < 0)
		goto out_clear;

	sigio_unlock();
	return;

out_clear:
	write_sigio_pid = -1;
	write_sigio_fds[0] = -1;
	write_sigio_fds[1] = -1;
	sigio_private[0] = -1;
	sigio_private[1] = -1;
out_clear_poll:
	current_poll = ((struct pollfds) { .poll	= NULL,
					   .size	= 0,
					   .used	= 0 });
out_free:
	sigio_unlock();
	kfree(p);
out_close2:
	close(l_sigio_private[0]);
	close(l_sigio_private[1]);
out_close1:
	close(l_write_sigio_fds[0]);
	close(l_write_sigio_fds[1]);
}

/* Changed during early boot */
static int pty_output_sigio = 0;
static int pty_close_sigio = 0;

void maybe_sigio_broken(int fd, int read)
{
	int err;

	if(!isatty(fd))
		return;

	if((read || pty_output_sigio) && (!read || pty_close_sigio))
		return;

	write_sigio_workaround();

	sigio_lock();
	err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
	if(err){
		printk("maybe_sigio_broken - failed to add pollfd for "
		       "descriptor %d\n", fd);
		goto out;
	}

	all_sigio_fds.poll[all_sigio_fds.used++] =
		((struct pollfd) { .fd  	= fd,
				   .events 	= read ? POLLIN : POLLOUT,
				   .revents 	= 0 });
out:
	sigio_unlock();
}

static void sigio_cleanup(void)
{
	if (write_sigio_pid == -1)
		return;

	os_kill_process(write_sigio_pid, 1);
	free_stack(write_sigio_stack, 0);
	write_sigio_pid = -1;
}

__uml_exitcall(sigio_cleanup);

/* Used as a flag during SIGIO testing early in boot */
static volatile int got_sigio = 0;

static void __init handler(int sig)
{
	got_sigio = 1;
}

struct openpty_arg {
	int master;
	int slave;
	int err;
};

static void openpty_cb(void *arg)
{
	struct openpty_arg *info = arg;

	info->err = 0;
	if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
		info->err = -errno;
}

static int async_pty(int master, int slave)
{
	int flags;

	flags = fcntl(master, F_GETFL);
	if(flags < 0)
		return -errno;

	if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
	   (fcntl(master, F_SETOWN, os_getpid()) < 0))
		return -errno;

	if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
		return -errno;

	return(0);
}

static void __init check_one_sigio(void (*proc)(int, int))
{
	struct sigaction old, new;
	struct openpty_arg pty = { .master = -1, .slave = -1 };
	int master, slave, err;

	initial_thread_cb(openpty_cb, &pty);
	if(pty.err){
		printk("openpty failed, errno = %d\n", -pty.err);
		return;
	}

	master = pty.master;
	slave = pty.slave;

	if((master == -1) || (slave == -1)){
		printk("openpty failed to allocate a pty\n");
		return;
	}

	/* Not now, but complain so we now where we failed. */
	err = raw(master);
	if (err < 0)
		panic("check_sigio : __raw failed, errno = %d\n", -err);

	err = async_pty(master, slave);
	if(err < 0)
		panic("tty_fds : sigio_async failed, err = %d\n", -err);

	if(sigaction(SIGIO, NULL, &old) < 0)
		panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
	new = old;
	new.sa_handler = handler;
	if(sigaction(SIGIO, &new, NULL) < 0)
		panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);

	got_sigio = 0;
	(*proc)(master, slave);

	close(master);
	close(slave);

	if(sigaction(SIGIO, &old, NULL) < 0)
		panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
}

static void tty_output(int master, int slave)
{
	int n;
	char buf[512];

	printk("Checking that host ptys support output SIGIO...");

	memset(buf, 0, sizeof(buf));

	while(write(master, buf, sizeof(buf)) > 0) ;
	if(errno != EAGAIN)
		panic("tty_output : write failed, errno = %d\n", errno);
	while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;

	if(got_sigio){
		printk("Yes\n");
		pty_output_sigio = 1;
	}
	else if(n == -EAGAIN)
		printk("No, enabling workaround\n");
	else panic("tty_output : read failed, err = %d\n", n);
}

static void tty_close(int master, int slave)
{
	printk("Checking that host ptys support SIGIO on close...");

	close(slave);
	if(got_sigio){
		printk("Yes\n");
		pty_close_sigio = 1;
	}
	else printk("No, enabling workaround\n");
}

void __init check_sigio(void)
{
	if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
	   (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
		printk("No pseudo-terminals available - skipping pty SIGIO "
		       "check\n");
		return;
	}
	check_one_sigio(tty_output);
	check_one_sigio(tty_close);
}

/* Here because it only does the SIGIO testing for now */
void __init os_check_bugs(void)
{
	check_sigio();
}
Commit	Line	Data
8e367065	1	/*
1da177e4 LT	2	* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include <unistd.h>
	7	#include <stdlib.h>
	8	#include <termios.h>
	9	#include <pty.h>
	10	#include <signal.h>
c65badbd	11	#include <fcntl.h>
1da177e4 LT	12	#include <errno.h>
	13	#include <string.h>
	14	#include <sched.h>
	15	#include <sys/socket.h>
	16	#include <sys/poll.h>
	17	#include "init.h"
	18	#include "user.h"
	19	#include "kern_util.h"
1da177e4	20	#include "sigio.h"
1da177e4	21	#include "os.h"
c13e5690	22	#include "um_malloc.h"
c65badbd	23	#include "init.h"
1da177e4	24
f206aabb	25	/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
1da177e4 LT	26	* exitcall.
	27	*/
	28	static int write_sigio_pid = -1;
c4399016	29	static unsigned long write_sigio_stack;
1da177e4 LT	30
	31	/* These arrays are initialized before the sigio thread is started, and
	32	* the descriptors closed after it is killed. So, it can't see them change.
	33	* On the UML side, they are changed under the sigio_lock.
	34	*/
5f4e8fd0 JD	35	#define SIGIO_FDS_INIT {-1, -1}
	36
	37	static int write_sigio_fds[2] = SIGIO_FDS_INIT;
	38	static int sigio_private[2] = SIGIO_FDS_INIT;
1da177e4 LT	39
	40	struct pollfds {
	41	struct pollfd *poll;
	42	int size;
	43	int used;
	44	};
	45
	46	/* Protected by sigio_lock(). Used by the sigio thread, but the UML thread
	47	* synchronizes with it.
	48	*/
19bdf040 JD	49	static struct pollfds current_poll;
	50	static struct pollfds next_poll;
	51	static struct pollfds all_sigio_fds;
1da177e4 LT	52
	53	static int write_sigio_thread(void *unused)
	54	{
	55	struct pollfds *fds, tmp;
	56	struct pollfd *p;
	57	int i, n, respond_fd;
	58	char c;
	59
cd2ee4a3	60	signal(SIGWINCH, SIG_IGN);
1da177e4 LT	61	fds = &current_poll;
	62	while(1){
	63	n = poll(fds->poll, fds->used, -1);
	64	if(n < 0){
	65	if(errno == EINTR) continue;
	66	printk("write_sigio_thread : poll returned %d, "
	67	"errno = %d\n", n, errno);
	68	}
	69	for(i = 0; i < fds->used; i++){
	70	p = &fds->poll[i];
	71	if(p->revents == 0) continue;
	72	if(p->fd == sigio_private[1]){
a61f334f JD	73	CATCH_EINTR(n = read(sigio_private[1], &c,
a61f334f JD	74	sizeof(c)));
1da177e4 LT	75	if(n != sizeof(c))
1da177e4 LT	76	printk("write_sigio_thread : "
19bdf040	77	"read on socket failed, "
a61f334f	78	"err = %d\n", errno);
1da177e4 LT	79	tmp = current_poll;
	80	current_poll = next_poll;
	81	next_poll = tmp;
	82	respond_fd = sigio_private[1];
	83	}
	84	else {
	85	respond_fd = write_sigio_fds[1];
	86	fds->used--;
	87	memmove(&fds->poll[i], &fds->poll[i + 1],
	88	(fds->used - i) * sizeof(*fds->poll));
	89	}
	90
a61f334f	91	CATCH_EINTR(n = write(respond_fd, &c, sizeof(c)));
1da177e4	92	if(n != sizeof(c))
19bdf040	93	printk("write_sigio_thread : write on socket "
a61f334f	94	"failed, err = %d\n", errno);
1da177e4 LT	95	}
1da177e4 LT	96	}
1b57e9c2 JD	97
1b57e9c2 JD	98	return 0;
1da177e4 LT	99	}
1da177e4 LT	100
19bdf040	101	static int need_poll(struct pollfds *polls, int n)
1da177e4	102	{
838e56a1 JD	103	struct pollfd *new;
	104
	105	if(n <= polls->size)
19bdf040	106	return 0;
838e56a1	107
e4c4bf99	108	new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC);
838e56a1	109	if(new == NULL){
1da177e4	110	printk("need_poll : failed to allocate new pollfds\n");
19bdf040	111	return -ENOMEM;
1da177e4	112	}
838e56a1 JD	113
	114	memcpy(new, polls->poll, polls->used * sizeof(struct pollfd));
	115	kfree(polls->poll);
	116
	117	polls->poll = new;
19bdf040	118	polls->size = n;
19bdf040	119	return 0;
1da177e4 LT	120	}
	121
	122	/* Must be called with sigio_lock held, because it's needed by the marked
19bdf040 JD	123	* critical section.
19bdf040 JD	124	*/
1da177e4 LT	125	static void update_thread(void)
	126	{
	127	unsigned long flags;
	128	int n;
	129	char c;
	130
	131	flags = set_signals(0);
a61f334f	132	n = write(sigio_private[0], &c, sizeof(c));
1da177e4	133	if(n != sizeof(c)){
a61f334f	134	printk("update_thread : write failed, err = %d\n", errno);
1da177e4 LT	135	goto fail;
	136	}
	137
a61f334f	138	CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c)));
1da177e4	139	if(n != sizeof(c)){
a61f334f	140	printk("update_thread : read failed, err = %d\n", errno);
1da177e4 LT	141	goto fail;
	142	}
	143
	144	set_signals(flags);
	145	return;
	146	fail:
	147	/* Critical section start */
c4399016	148	if (write_sigio_pid != -1) {
1da177e4	149	os_kill_process(write_sigio_pid, 1);
c4399016 JD	150	free_stack(write_sigio_stack, 0);
c4399016 JD	151	}
1da177e4	152	write_sigio_pid = -1;
8e367065 JD	153	close(sigio_private[0]);
	154	close(sigio_private[1]);
	155	close(write_sigio_fds[0]);
	156	close(write_sigio_fds[1]);
1da177e4 LT	157	/* Critical section end */
	158	set_signals(flags);
	159	}
	160
19bdf040	161	int add_sigio_fd(int fd)
1da177e4	162	{
19bdf040 JD	163	struct pollfd *p;
19bdf040 JD	164	int err = 0, i, n;
1da177e4 LT	165
1da177e4 LT	166	sigio_lock();
19bdf040 JD	167	for(i = 0; i < all_sigio_fds.used; i++){
	168	if(all_sigio_fds.poll[i].fd == fd)
	169	break;
	170	}
	171	if(i == all_sigio_fds.used)
	172	goto out;
	173
	174	p = &all_sigio_fds.poll[i];
	175
1da177e4	176	for(i = 0; i < current_poll.used; i++){
f206aabb	177	if(current_poll.poll[i].fd == fd)
1da177e4 LT	178	goto out;
	179	}
	180
838e56a1 JD	181	n = current_poll.used;
838e56a1 JD	182	err = need_poll(&next_poll, n + 1);
f206aabb	183	if(err)
1da177e4 LT	184	goto out;
1da177e4 LT	185
838e56a1 JD	186	memcpy(next_poll.poll, current_poll.poll,
	187	current_poll.used * sizeof(struct pollfd));
	188	next_poll.poll[n] = *p;
	189	next_poll.used = n + 1;
1da177e4 LT	190	update_thread();
	191	out:
	192	sigio_unlock();
19bdf040	193	return err;
1da177e4 LT	194	}
	195
	196	int ignore_sigio_fd(int fd)
	197	{
	198	struct pollfd *p;
	199	int err = 0, i, n = 0;
	200
61232f2f JD	201	/* This is called from exitcalls elsewhere in UML - if
	202	* sigio_cleanup has already run, then update_thread will hang
	203	* or fail because the thread is no longer running.
	204	*/
	205	if(write_sigio_pid == -1)
	206	return -EIO;
	207
1da177e4 LT	208	sigio_lock();
	209	for(i = 0; i < current_poll.used; i++){
	210	if(current_poll.poll[i].fd == fd) break;
	211	}
	212	if(i == current_poll.used)
	213	goto out;
f206aabb	214
19bdf040	215	err = need_poll(&next_poll, current_poll.used - 1);
1da177e4 LT	216	if(err)
	217	goto out;
	218
	219	for(i = 0; i < current_poll.used; i++){
	220	p = &current_poll.poll[i];
19bdf040 JD	221	if(p->fd != fd)
19bdf040 JD	222	next_poll.poll[n++] = *p;
1da177e4	223	}
838e56a1	224	next_poll.used = current_poll.used - 1;
1da177e4 LT	225
	226	update_thread();
	227	out:
	228	sigio_unlock();
61232f2f	229	return err;
1da177e4 LT	230	}
1da177e4 LT	231
f206aabb	232	static struct pollfd *setup_initial_poll(int fd)
1da177e4 LT	233	{
	234	struct pollfd *p;
	235
e4c4bf99	236	p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL);
b6a2b137	237	if (p == NULL) {
1da177e4	238	printk("setup_initial_poll : failed to allocate poll\n");
b6a2b137	239	return NULL;
1da177e4	240	}
19bdf040	241	*p = ((struct pollfd) { .fd = fd,
1da177e4 LT	242	.events = POLLIN,
1da177e4 LT	243	.revents = 0 });
b6a2b137	244	return p;
1da177e4 LT	245	}
1da177e4 LT	246
8e64d96a	247	static void write_sigio_workaround(void)
1da177e4	248	{
b6a2b137	249	struct pollfd *p;
1da177e4	250	int err;
b6a2b137 PBG	251	int l_write_sigio_fds[2];
	252	int l_sigio_private[2];
	253	int l_write_sigio_pid;
1da177e4	254
b6a2b137	255	/* We call this tons of times - and most ones we must just fail. */
1da177e4	256	sigio_lock();
b6a2b137 PBG	257	l_write_sigio_pid = write_sigio_pid;
b6a2b137 PBG	258	sigio_unlock();
1da177e4	259
b6a2b137 PBG	260	if (l_write_sigio_pid != -1)
	261	return;
	262
	263	err = os_pipe(l_write_sigio_fds, 1, 1);
1da177e4 LT	264	if(err < 0){
	265	printk("write_sigio_workaround - os_pipe 1 failed, "
	266	"err = %d\n", -err);
b6a2b137	267	return;
1da177e4	268	}
b6a2b137	269	err = os_pipe(l_sigio_private, 1, 1);
1da177e4	270	if(err < 0){
f206aabb	271	printk("write_sigio_workaround - os_pipe 2 failed, "
1da177e4 LT	272	"err = %d\n", -err);
	273	goto out_close1;
	274	}
b6a2b137 PBG	275
	276	p = setup_initial_poll(l_sigio_private[1]);
	277	if(!p)
1da177e4 LT	278	goto out_close2;
1da177e4 LT	279
b6a2b137 PBG	280	sigio_lock();
	281
	282	/* Did we race? Don't try to optimize this, please, it's not so likely
	283	* to happen, and no more than once at the boot. */
	284	if(write_sigio_pid != -1)
5f4e8fd0	285	goto out_free;
1da177e4	286
5f4e8fd0 JD	287	current_poll = ((struct pollfds) { .poll = p,
	288	.used = 1,
	289	.size = 1 });
1da177e4	290
b6a2b137	291	if (write_sigio_irq(l_write_sigio_fds[0]))
5f4e8fd0	292	goto out_clear_poll;
1da177e4	293
b6a2b137 PBG	294	memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
	295	memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
	296
5f4e8fd0	297	write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
c4399016 JD	298	CLONE_FILES \| CLONE_VM,
c4399016 JD	299	&write_sigio_stack);
b6a2b137	300
5f4e8fd0 JD	301	if (write_sigio_pid < 0)
5f4e8fd0 JD	302	goto out_clear;
1da177e4	303
b6a2b137	304	sigio_unlock();
5f4e8fd0	305	return;
b6a2b137	306
5f4e8fd0	307	out_clear:
b6a2b137	308	write_sigio_pid = -1;
5f4e8fd0 JD	309	write_sigio_fds[0] = -1;
	310	write_sigio_fds[1] = -1;
	311	sigio_private[0] = -1;
	312	sigio_private[1] = -1;
	313	out_clear_poll:
	314	current_poll = ((struct pollfds) { .poll = NULL,
	315	.size = 0,
	316	.used = 0 });
	317	out_free:
5f4e8fd0	318	sigio_unlock();
e6fb54ab	319	kfree(p);
5f4e8fd0	320	out_close2:
8e367065 JD	321	close(l_sigio_private[0]);
8e367065 JD	322	close(l_sigio_private[1]);
5f4e8fd0	323	out_close1:
8e367065 JD	324	close(l_write_sigio_fds[0]);
8e367065 JD	325	close(l_write_sigio_fds[1]);
1da177e4 LT	326	}
1da177e4 LT	327
c65badbd JD	328	/* Changed during early boot */
	329	static int pty_output_sigio = 0;
	330	static int pty_close_sigio = 0;
	331
8e64d96a JD	332	void maybe_sigio_broken(int fd, int read)
8e64d96a JD	333	{
19bdf040 JD	334	int err;
19bdf040 JD	335
8e64d96a JD	336	if(!isatty(fd))
	337	return;
	338
	339	if((read \|\| pty_output_sigio) && (!read \|\| pty_close_sigio))
	340	return;
	341
	342	write_sigio_workaround();
19bdf040 JD	343
	344	sigio_lock();
	345	err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
04a51e66 JD	346	if(err){
	347	printk("maybe_sigio_broken - failed to add pollfd for "
	348	"descriptor %d\n", fd);
19bdf040	349	goto out;
04a51e66	350	}
838e56a1	351
19bdf040 JD	352	all_sigio_fds.poll[all_sigio_fds.used++] =
	353	((struct pollfd) { .fd = fd,
	354	.events = read ? POLLIN : POLLOUT,
	355	.revents = 0 });
	356	out:
	357	sigio_unlock();
8e64d96a JD	358	}
8e64d96a JD	359
29ac1c21	360	static void sigio_cleanup(void)
1da177e4	361	{
c4399016 JD	362	if (write_sigio_pid == -1)
	363	return;
	364
	365	os_kill_process(write_sigio_pid, 1);
	366	free_stack(write_sigio_stack, 0);
	367	write_sigio_pid = -1;
1da177e4	368	}
29ac1c21 JD	369
29ac1c21 JD	370	__uml_exitcall(sigio_cleanup);
c65badbd JD	371
	372	/* Used as a flag during SIGIO testing early in boot */
	373	static volatile int got_sigio = 0;
	374
	375	static void __init handler(int sig)
	376	{
	377	got_sigio = 1;
	378	}
	379
	380	struct openpty_arg {
	381	int master;
	382	int slave;
	383	int err;
	384	};
	385
	386	static void openpty_cb(void *arg)
	387	{
	388	struct openpty_arg *info = arg;
	389
	390	info->err = 0;
	391	if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
	392	info->err = -errno;
	393	}
	394
	395	static int async_pty(int master, int slave)
	396	{
	397	int flags;
	398
	399	flags = fcntl(master, F_GETFL);
	400	if(flags < 0)
	401	return -errno;
	402
	403	if((fcntl(master, F_SETFL, flags \| O_NONBLOCK \| O_ASYNC) < 0) \|\|
	404	(fcntl(master, F_SETOWN, os_getpid()) < 0))
	405	return -errno;
	406
	407	if((fcntl(slave, F_SETFL, flags \| O_NONBLOCK) < 0))
	408	return -errno;
	409
	410	return(0);
	411	}
	412
	413	static void __init check_one_sigio(void (*proc)(int, int))
	414	{
	415	struct sigaction old, new;
	416	struct openpty_arg pty = { .master = -1, .slave = -1 };
	417	int master, slave, err;
	418
	419	initial_thread_cb(openpty_cb, &pty);
	420	if(pty.err){
	421	printk("openpty failed, errno = %d\n", -pty.err);
	422	return;
	423	}
	424
	425	master = pty.master;
	426	slave = pty.slave;
	427
	428	if((master == -1) \|\| (slave == -1)){
	429	printk("openpty failed to allocate a pty\n");
	430	return;
	431	}
	432
	433	/* Not now, but complain so we now where we failed. */
	434	err = raw(master);
435	if (err < 0)
436	panic("check_sigio : __raw failed, errno = %d\n", -err);
437
438	err = async_pty(master, slave);
439	if(err < 0)
440	panic("tty_fds : sigio_async failed, err = %d\n", -err);
441
442	if(sigaction(SIGIO, NULL, &old) < 0)
443	panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
444	new = old;
445	new.sa_handler = handler;
446	if(sigaction(SIGIO, &new, NULL) < 0)
447	panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
448
449	got_sigio = 0;
450	(*proc)(master, slave);
451
452	close(master);
453	close(slave);
454
455	if(sigaction(SIGIO, &old, NULL) < 0)
456	panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
457	}
458
459	static void tty_output(int master, int slave)
460	{
461	int n;
462	char buf[512];
463
464	printk("Checking that host ptys support output SIGIO...");
465
466	memset(buf, 0, sizeof(buf));
467
a61f334f	468	while(write(master, buf, sizeof(buf)) > 0) ;
c65badbd	469	if(errno != EAGAIN)
ef0470c0	470	panic("tty_output : write failed, errno = %d\n", errno);
a61f334f	471	while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
c65badbd JD	472
	473	if(got_sigio){
	474	printk("Yes\n");
	475	pty_output_sigio = 1;
	476	}
ef0470c0 JD	477	else if(n == -EAGAIN)
	478	printk("No, enabling workaround\n");
	479	else panic("tty_output : read failed, err = %d\n", n);
c65badbd JD	480	}
	481
	482	static void tty_close(int master, int slave)
	483	{
	484	printk("Checking that host ptys support SIGIO on close...");
	485
	486	close(slave);
	487	if(got_sigio){
	488	printk("Yes\n");
	489	pty_close_sigio = 1;
	490	}
	491	else printk("No, enabling workaround\n");
	492	}
	493
	494	void __init check_sigio(void)
	495	{
	496	if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
	497	(os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
	498	printk("No pseudo-terminals available - skipping pty SIGIO "
	499	"check\n");
	500	return;
	501	}
	502	check_one_sigio(tty_output);
	503	check_one_sigio(tty_close);
	504	}
	505
	506	/* Here because it only does the SIGIO testing for now */
	507	void __init os_check_bugs(void)
	508	{
	509	check_sigio();
	510	}