2006-03-27 02:14:32 -07:00
|
|
|
/*
|
2005-04-16 15:20:36 -07:00
|
|
|
* 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 <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 "user_util.h"
|
|
|
|
#include "sigio.h"
|
|
|
|
#include "os.h"
|
|
|
|
|
2006-03-27 02:14:33 -07:00
|
|
|
/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
|
2005-04-16 15:20:36 -07:00
|
|
|
* exitcall.
|
|
|
|
*/
|
|
|
|
static int write_sigio_pid = -1;
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2006-03-27 02:14:40 -07:00
|
|
|
#define SIGIO_FDS_INIT {-1, -1}
|
|
|
|
|
|
|
|
static int write_sigio_fds[2] = SIGIO_FDS_INIT;
|
|
|
|
static int sigio_private[2] = SIGIO_FDS_INIT;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
static struct pollfds current_poll;
|
|
|
|
static struct pollfds next_poll;
|
|
|
|
static struct pollfds all_sigio_fds;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
static int write_sigio_thread(void *unused)
|
|
|
|
{
|
|
|
|
struct pollfds *fds, tmp;
|
|
|
|
struct pollfd *p;
|
|
|
|
int i, n, respond_fd;
|
|
|
|
char c;
|
|
|
|
|
2005-05-05 16:15:32 -07:00
|
|
|
signal(SIGWINCH, SIG_IGN);
|
2005-04-16 15:20:36 -07:00
|
|
|
fds = ¤t_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]){
|
|
|
|
n = os_read_file(sigio_private[1], &c, sizeof(c));
|
|
|
|
if(n != sizeof(c))
|
|
|
|
printk("write_sigio_thread : "
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
"read on socket failed, "
|
|
|
|
"err = %d\n", -n);
|
2005-04-16 15:20:36 -07:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
|
|
|
n = os_write_file(respond_fd, &c, sizeof(c));
|
|
|
|
if(n != sizeof(c))
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
printk("write_sigio_thread : write on socket "
|
|
|
|
"failed, err = %d\n", -n);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
}
|
2006-01-06 01:18:49 -07:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
static int need_poll(struct pollfds *polls, int n)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
if(n <= polls->size){
|
|
|
|
polls->used = n;
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
kfree(polls->poll);
|
|
|
|
polls->poll = um_kmalloc_atomic(n * sizeof(struct pollfd));
|
|
|
|
if(polls->poll == NULL){
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("need_poll : failed to allocate new pollfds\n");
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
polls->size = 0;
|
|
|
|
polls->used = 0;
|
|
|
|
return -ENOMEM;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
polls->size = n;
|
|
|
|
polls->used = n;
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Must be called with sigio_lock held, because it's needed by the marked
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
* critical section.
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
static void update_thread(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int n;
|
|
|
|
char c;
|
|
|
|
|
|
|
|
flags = set_signals(0);
|
|
|
|
n = os_write_file(sigio_private[0], &c, sizeof(c));
|
|
|
|
if(n != sizeof(c)){
|
|
|
|
printk("update_thread : write failed, err = %d\n", -n);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = os_read_file(sigio_private[0], &c, sizeof(c));
|
|
|
|
if(n != sizeof(c)){
|
|
|
|
printk("update_thread : read failed, err = %d\n", -n);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_signals(flags);
|
|
|
|
return;
|
|
|
|
fail:
|
|
|
|
/* Critical section start */
|
2006-03-27 02:14:33 -07:00
|
|
|
if(write_sigio_pid != -1)
|
2005-04-16 15:20:36 -07:00
|
|
|
os_kill_process(write_sigio_pid, 1);
|
|
|
|
write_sigio_pid = -1;
|
2006-03-27 02:14:32 -07:00
|
|
|
close(sigio_private[0]);
|
|
|
|
close(sigio_private[1]);
|
|
|
|
close(write_sigio_fds[0]);
|
|
|
|
close(write_sigio_fds[1]);
|
2005-04-16 15:20:36 -07:00
|
|
|
/* Critical section end */
|
|
|
|
set_signals(flags);
|
|
|
|
}
|
|
|
|
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
int add_sigio_fd(int fd)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
struct pollfd *p;
|
|
|
|
int err = 0, i, n;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
sigio_lock();
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
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];
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
for(i = 0; i < current_poll.used; i++){
|
2006-03-27 02:14:33 -07:00
|
|
|
if(current_poll.poll[i].fd == fd)
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = current_poll.used + 1;
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
err = need_poll(&next_poll, n);
|
2006-03-27 02:14:33 -07:00
|
|
|
if(err)
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
for(i = 0; i < current_poll.used; i++)
|
|
|
|
next_poll.poll[i] = current_poll.poll[i];
|
|
|
|
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
next_poll.poll[n - 1] = *p;
|
2005-04-16 15:20:36 -07:00
|
|
|
update_thread();
|
|
|
|
out:
|
|
|
|
sigio_unlock();
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
return err;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int ignore_sigio_fd(int fd)
|
|
|
|
{
|
|
|
|
struct pollfd *p;
|
|
|
|
int err = 0, i, n = 0;
|
|
|
|
|
2006-07-10 04:45:11 -07:00
|
|
|
/* 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;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
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;
|
2006-03-27 02:14:33 -07:00
|
|
|
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
err = need_poll(&next_poll, current_poll.used - 1);
|
2005-04-16 15:20:36 -07:00
|
|
|
if(err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for(i = 0; i < current_poll.used; i++){
|
|
|
|
p = ¤t_poll.poll[i];
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
if(p->fd != fd)
|
|
|
|
next_poll.poll[n++] = *p;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
update_thread();
|
|
|
|
out:
|
|
|
|
sigio_unlock();
|
2006-07-10 04:45:11 -07:00
|
|
|
return err;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-03-27 02:14:33 -07:00
|
|
|
static struct pollfd *setup_initial_poll(int fd)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct pollfd *p;
|
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
p = um_kmalloc(sizeof(struct pollfd));
|
|
|
|
if (p == NULL) {
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("setup_initial_poll : failed to allocate poll\n");
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
return NULL;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
*p = ((struct pollfd) { .fd = fd,
|
2005-04-16 15:20:36 -07:00
|
|
|
.events = POLLIN,
|
|
|
|
.revents = 0 });
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
return p;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-07-10 04:45:11 -07:00
|
|
|
static void write_sigio_workaround(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
unsigned long stack;
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
struct pollfd *p;
|
2005-04-16 15:20:36 -07:00
|
|
|
int err;
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
int l_write_sigio_fds[2];
|
|
|
|
int l_sigio_private[2];
|
|
|
|
int l_write_sigio_pid;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
/* We call this *tons* of times - and most ones we must just fail. */
|
2005-04-16 15:20:36 -07:00
|
|
|
sigio_lock();
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
l_write_sigio_pid = write_sigio_pid;
|
|
|
|
sigio_unlock();
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
if (l_write_sigio_pid != -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = os_pipe(l_write_sigio_fds, 1, 1);
|
2005-04-16 15:20:36 -07:00
|
|
|
if(err < 0){
|
|
|
|
printk("write_sigio_workaround - os_pipe 1 failed, "
|
|
|
|
"err = %d\n", -err);
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
return;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
err = os_pipe(l_sigio_private, 1, 1);
|
2005-04-16 15:20:36 -07:00
|
|
|
if(err < 0){
|
2006-03-27 02:14:33 -07:00
|
|
|
printk("write_sigio_workaround - os_pipe 2 failed, "
|
2005-04-16 15:20:36 -07:00
|
|
|
"err = %d\n", -err);
|
|
|
|
goto out_close1;
|
|
|
|
}
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
|
|
|
|
p = setup_initial_poll(l_sigio_private[1]);
|
|
|
|
if(!p)
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_close2;
|
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
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)
|
2006-03-27 02:14:40 -07:00
|
|
|
goto out_free;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-03-27 02:14:40 -07:00
|
|
|
current_poll = ((struct pollfds) { .poll = p,
|
|
|
|
.used = 1,
|
|
|
|
.size = 1 });
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
if (write_sigio_irq(l_write_sigio_fds[0]))
|
2006-03-27 02:14:40 -07:00
|
|
|
goto out_clear_poll;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
|
|
|
|
memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
|
|
|
|
|
2006-03-27 02:14:40 -07:00
|
|
|
write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
|
|
|
|
CLONE_FILES | CLONE_VM, &stack, 0);
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
|
2006-03-27 02:14:40 -07:00
|
|
|
if (write_sigio_pid < 0)
|
|
|
|
goto out_clear;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
sigio_unlock();
|
2006-03-27 02:14:40 -07:00
|
|
|
return;
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
|
2006-03-27 02:14:40 -07:00
|
|
|
out_clear:
|
[PATCH] uml: sigio code - reduce spinlock hold time
In a previous patch I shifted an allocation to being atomic.
In this patch, a better but more intrusive solution is implemented, i.e. hold
the lock only when really needing it, especially not over pipe operations, nor
over the culprit allocation.
Additionally, while at it, add a missing kfree in the failure path, and make
sure that if we fail in forking, write_sigio_pid is -1 and not, say, -ENOMEM.
And fix whitespace, at least for things I was touching anyway.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-18 18:42:57 -07:00
|
|
|
write_sigio_pid = -1;
|
2006-03-27 02:14:40 -07:00
|
|
|
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();
|
2006-04-10 22:53:36 -07:00
|
|
|
kfree(p);
|
2006-03-27 02:14:40 -07:00
|
|
|
out_close2:
|
2006-03-27 02:14:32 -07:00
|
|
|
close(l_sigio_private[0]);
|
|
|
|
close(l_sigio_private[1]);
|
2006-03-27 02:14:40 -07:00
|
|
|
out_close1:
|
2006-03-27 02:14:32 -07:00
|
|
|
close(l_write_sigio_fds[0]);
|
|
|
|
close(l_write_sigio_fds[1]);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-07-10 04:45:11 -07:00
|
|
|
void maybe_sigio_broken(int fd, int read)
|
|
|
|
{
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
int err;
|
|
|
|
|
2006-07-10 04:45:11 -07:00
|
|
|
if(!isatty(fd))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if((read || pty_output_sigio) && (!read || pty_close_sigio))
|
|
|
|
return;
|
|
|
|
|
|
|
|
write_sigio_workaround();
|
[PATCH] uml: SIGIO cleanups
- Various cleanups in the sigio code.
- Removed explicit zero-initializations of a few structures.
- Improved some error messages.
- An API change - there was an asymmetry between reactivate_fd calling
maybe_sigio_broken, which goes through all the machinery of figuring out if
a file descriptor supports SIGIO and applying the workaround to it if not,
and deactivate_fd, which just turns off the descriptor.
This is changed so that only activate_fd calls maybe_sigio_broken, when
the descriptor is first seen. reactivate_fd now calls add_sigio_fd, which
is symmetric with ignore_sigio_fd.
This removes a recursion which makes a critical section look more critical
than it really was, obsoleting a big comment to that effect. This requires
keeping track of all descriptors which are getting the SIGIO treatment, not
just the ones being polled at any given moment, so that reactivate_fd,
through add_sigio_fd, doesn't try to tell the SIGIO thread about descriptors
it doesn't care about.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-25 23:33:04 -07:00
|
|
|
|
|
|
|
sigio_lock();
|
|
|
|
err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
|
|
|
|
if(err){
|
|
|
|
printk("maybe_sigio_broken - failed to add pollfd\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
all_sigio_fds.poll[all_sigio_fds.used++] =
|
|
|
|
((struct pollfd) { .fd = fd,
|
|
|
|
.events = read ? POLLIN : POLLOUT,
|
|
|
|
.revents = 0 });
|
|
|
|
out:
|
|
|
|
sigio_unlock();
|
2006-07-10 04:45:11 -07:00
|
|
|
}
|
|
|
|
|
2006-07-10 04:45:12 -07:00
|
|
|
static void sigio_cleanup(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-03-27 02:14:33 -07:00
|
|
|
if(write_sigio_pid != -1){
|
2005-04-16 15:20:36 -07:00
|
|
|
os_kill_process(write_sigio_pid, 1);
|
|
|
|
write_sigio_pid = -1;
|
|
|
|
}
|
|
|
|
}
|
2006-07-10 04:45:12 -07:00
|
|
|
|
|
|
|
__uml_exitcall(sigio_cleanup);
|