2005-04-17 02:20:36 +04:00
/*
* linux / fs / fcntl . c
*
* Copyright ( C ) 1991 , 1992 Linus Torvalds
*/
# include <linux/syscalls.h>
# include <linux/init.h>
# include <linux/mm.h>
# include <linux/fs.h>
# include <linux/file.h>
2008-04-24 15:44:08 +04:00
# include <linux/fdtable.h>
2006-01-11 23:17:46 +03:00
# include <linux/capability.h>
2005-04-17 02:20:36 +04:00
# include <linux/dnotify.h>
# include <linux/slab.h>
# include <linux/module.h>
# include <linux/security.h>
# include <linux/ptrace.h>
2005-05-01 19:59:14 +04:00
# include <linux/signal.h>
2005-09-10 00:04:13 +04:00
# include <linux/rcupdate.h>
2007-10-19 10:40:14 +04:00
# include <linux/pid_namespace.h>
2005-04-17 02:20:36 +04:00
# include <asm/poll.h>
# include <asm/siginfo.h>
# include <asm/uaccess.h>
2008-02-08 15:19:52 +03:00
void set_close_on_exec ( unsigned int fd , int flag )
2005-04-17 02:20:36 +04:00
{
struct files_struct * files = current - > files ;
2005-09-10 00:04:10 +04:00
struct fdtable * fdt ;
2005-04-17 02:20:36 +04:00
spin_lock ( & files - > file_lock ) ;
2005-09-10 00:04:10 +04:00
fdt = files_fdtable ( files ) ;
2005-04-17 02:20:36 +04:00
if ( flag )
2005-09-10 00:04:10 +04:00
FD_SET ( fd , fdt - > close_on_exec ) ;
2005-04-17 02:20:36 +04:00
else
2005-09-10 00:04:10 +04:00
FD_CLR ( fd , fdt - > close_on_exec ) ;
2005-04-17 02:20:36 +04:00
spin_unlock ( & files - > file_lock ) ;
}
2006-01-15 00:20:43 +03:00
static int get_close_on_exec ( unsigned int fd )
2005-04-17 02:20:36 +04:00
{
struct files_struct * files = current - > files ;
2005-09-10 00:04:10 +04:00
struct fdtable * fdt ;
2005-04-17 02:20:36 +04:00
int res ;
2005-09-10 00:04:14 +04:00
rcu_read_lock ( ) ;
2005-09-10 00:04:10 +04:00
fdt = files_fdtable ( files ) ;
res = FD_ISSET ( fd , fdt - > close_on_exec ) ;
2005-09-10 00:04:14 +04:00
rcu_read_unlock ( ) ;
2005-04-17 02:20:36 +04:00
return res ;
}
2008-07-24 08:29:29 +04:00
asmlinkage long sys_dup3 ( unsigned int oldfd , unsigned int newfd , int flags )
2005-04-17 02:20:36 +04:00
{
int err = - EBADF ;
struct file * file , * tofree ;
struct files_struct * files = current - > files ;
2005-09-10 00:04:10 +04:00
struct fdtable * fdt ;
2005-04-17 02:20:36 +04:00
2008-07-24 08:29:29 +04:00
if ( ( flags & ~ O_CLOEXEC ) ! = 0 )
return - EINVAL ;
2008-07-26 21:38:19 +04:00
if ( unlikely ( oldfd = = newfd ) )
return - EINVAL ;
2005-04-17 02:20:36 +04:00
spin_lock ( & files - > file_lock ) ;
err = expand_files ( files , newfd ) ;
2008-07-30 14:18:03 +04:00
file = fcheck ( oldfd ) ;
if ( unlikely ( ! file ) )
goto Ebadf ;
2008-07-27 00:01:20 +04:00
if ( unlikely ( err < 0 ) ) {
if ( err = = - EMFILE )
2008-07-30 14:18:03 +04:00
goto Ebadf ;
goto out_unlock ;
2008-07-27 00:01:20 +04:00
}
2008-07-30 14:18:03 +04:00
/*
* We need to detect attempts to do dup2 ( ) over allocated but still
* not finished descriptor . NB : OpenBSD avoids that at the price of
* extra work in their equivalent of fget ( ) - they insert struct
* file immediately after grabbing descriptor , mark it larval if
* more work ( e . g . actual opening ) is needed and make sure that
* fget ( ) treats larval files as absent . Potentially interesting ,
* but while extra work in fget ( ) is trivial , locking implications
* and amount of surgery on open ( ) - related paths in VFS are not .
* FreeBSD fails with - EBADF in the same situation , NetBSD " solution "
* deadlocks in rather amusing ways , AFAICS . All of that is out of
* scope of POSIX or SUS , since neither considers shared descriptor
* tables and this condition does not arise without those .
*/
2005-04-17 02:20:36 +04:00
err = - EBUSY ;
2005-09-10 00:04:10 +04:00
fdt = files_fdtable ( files ) ;
tofree = fdt - > fd [ newfd ] ;
if ( ! tofree & & FD_ISSET ( newfd , fdt - > open_fds ) )
2008-07-30 14:18:03 +04:00
goto out_unlock ;
get_file ( file ) ;
2005-09-10 00:04:13 +04:00
rcu_assign_pointer ( fdt - > fd [ newfd ] , file ) ;
2005-09-10 00:04:10 +04:00
FD_SET ( newfd , fdt - > open_fds ) ;
2008-07-24 08:29:29 +04:00
if ( flags & O_CLOEXEC )
FD_SET ( newfd , fdt - > close_on_exec ) ;
else
FD_CLR ( newfd , fdt - > close_on_exec ) ;
2005-04-17 02:20:36 +04:00
spin_unlock ( & files - > file_lock ) ;
if ( tofree )
filp_close ( tofree , files ) ;
2008-07-30 14:18:03 +04:00
return newfd ;
Ebadf :
err = - EBADF ;
out_unlock :
2005-04-17 02:20:36 +04:00
spin_unlock ( & files - > file_lock ) ;
2008-07-30 14:18:03 +04:00
return err ;
2005-04-17 02:20:36 +04:00
}
2008-07-24 08:29:29 +04:00
asmlinkage long sys_dup2 ( unsigned int oldfd , unsigned int newfd )
{
2008-07-26 21:38:19 +04:00
if ( unlikely ( newfd = = oldfd ) ) { /* corner case */
struct files_struct * files = current - > files ;
rcu_read_lock ( ) ;
if ( ! fcheck_files ( files , oldfd ) )
oldfd = - EBADF ;
rcu_read_unlock ( ) ;
return oldfd ;
}
2008-07-24 08:29:29 +04:00
return sys_dup3 ( oldfd , newfd , 0 ) ;
}
2005-04-17 02:20:36 +04:00
asmlinkage long sys_dup ( unsigned int fildes )
{
int ret = - EBADF ;
2008-07-30 12:13:04 +04:00
struct file * file = fget ( fildes ) ;
if ( file ) {
ret = get_unused_fd ( ) ;
if ( ret > = 0 )
fd_install ( ret , file ) ;
else
fput ( file ) ;
}
2005-04-17 02:20:36 +04:00
return ret ;
}
# define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | FASYNC | O_DIRECT | O_NOATIME)
static int setfl ( int fd , struct file * filp , unsigned long arg )
{
2006-12-08 13:36:35 +03:00
struct inode * inode = filp - > f_path . dentry - > d_inode ;
2005-04-17 02:20:36 +04:00
int error = 0 ;
2006-02-03 14:04:30 +03:00
/*
* O_APPEND cannot be cleared if the file is marked as append - only
* and the file is open for write .
*/
if ( ( ( arg ^ filp - > f_flags ) & O_APPEND ) & & IS_APPEND ( inode ) )
2005-04-17 02:20:36 +04:00
return - EPERM ;
/* O_NOATIME can only be set by the owner or superuser */
if ( ( arg & O_NOATIME ) & & ! ( filp - > f_flags & O_NOATIME ) )
2007-07-17 13:30:08 +04:00
if ( ! is_owner_or_cap ( inode ) )
2005-04-17 02:20:36 +04:00
return - EPERM ;
/* required for strict SunOS emulation */
if ( O_NONBLOCK ! = O_NDELAY )
if ( arg & O_NDELAY )
arg | = O_NONBLOCK ;
if ( arg & O_DIRECT ) {
if ( ! filp - > f_mapping | | ! filp - > f_mapping - > a_ops | |
! filp - > f_mapping - > a_ops - > direct_IO )
return - EINVAL ;
}
if ( filp - > f_op & & filp - > f_op - > check_flags )
error = filp - > f_op - > check_flags ( arg ) ;
if ( error )
return error ;
if ( ( arg ^ filp - > f_flags ) & FASYNC ) {
if ( filp - > f_op & & filp - > f_op - > fasync ) {
error = filp - > f_op - > fasync ( fd , filp , ( arg & FASYNC ) ! = 0 ) ;
if ( error < 0 )
goto out ;
}
}
filp - > f_flags = ( arg & SETFL_MASK ) | ( filp - > f_flags & ~ SETFL_MASK ) ;
out :
return error ;
}
2006-10-02 13:17:15 +04:00
static void f_modown ( struct file * filp , struct pid * pid , enum pid_type type ,
2005-04-17 02:20:36 +04:00
uid_t uid , uid_t euid , int force )
{
write_lock_irq ( & filp - > f_owner . lock ) ;
if ( force | | ! filp - > f_owner . pid ) {
2006-10-02 13:17:15 +04:00
put_pid ( filp - > f_owner . pid ) ;
filp - > f_owner . pid = get_pid ( pid ) ;
filp - > f_owner . pid_type = type ;
2005-04-17 02:20:36 +04:00
filp - > f_owner . uid = uid ;
filp - > f_owner . euid = euid ;
}
write_unlock_irq ( & filp - > f_owner . lock ) ;
}
2006-10-02 13:17:15 +04:00
int __f_setown ( struct file * filp , struct pid * pid , enum pid_type type ,
int force )
2005-04-17 02:20:36 +04:00
{
int err ;
err = security_file_set_fowner ( filp ) ;
if ( err )
return err ;
2008-11-14 02:39:05 +03:00
f_modown ( filp , pid , type , current_uid ( ) , current_euid ( ) , force ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
2006-10-02 13:17:15 +04:00
EXPORT_SYMBOL ( __f_setown ) ;
2005-04-17 02:20:36 +04:00
2006-10-02 13:17:15 +04:00
int f_setown ( struct file * filp , unsigned long arg , int force )
{
enum pid_type type ;
struct pid * pid ;
int who = arg ;
int result ;
type = PIDTYPE_PID ;
if ( who < 0 ) {
type = PIDTYPE_PGID ;
who = - who ;
}
rcu_read_lock ( ) ;
2007-10-19 10:40:14 +04:00
pid = find_vpid ( who ) ;
2006-10-02 13:17:15 +04:00
result = __f_setown ( filp , pid , type , force ) ;
rcu_read_unlock ( ) ;
return result ;
}
2005-04-17 02:20:36 +04:00
EXPORT_SYMBOL ( f_setown ) ;
void f_delown ( struct file * filp )
{
2006-10-02 13:17:15 +04:00
f_modown ( filp , NULL , PIDTYPE_PID , 0 , 0 , 1 ) ;
}
pid_t f_getown ( struct file * filp )
{
pid_t pid ;
2006-10-02 13:17:27 +04:00
read_lock ( & filp - > f_owner . lock ) ;
2008-02-08 15:19:20 +03:00
pid = pid_vnr ( filp - > f_owner . pid ) ;
2006-10-02 13:17:15 +04:00
if ( filp - > f_owner . pid_type = = PIDTYPE_PGID )
pid = - pid ;
2006-10-02 13:17:27 +04:00
read_unlock ( & filp - > f_owner . lock ) ;
2006-10-02 13:17:15 +04:00
return pid ;
2005-04-17 02:20:36 +04:00
}
static long do_fcntl ( int fd , unsigned int cmd , unsigned long arg ,
struct file * filp )
{
long err = - EINVAL ;
switch ( cmd ) {
case F_DUPFD :
F_DUPFD_CLOEXEC implementation
One more small change to extend the availability of creation of file
descriptors with FD_CLOEXEC set. Adding a new command to fcntl() requires
no new system call and the overall impact on code size if minimal.
If this patch gets accepted we will also add this change to the next
revision of the POSIX spec.
To test the patch, use the following little program. Adjust the value of
F_DUPFD_CLOEXEC appropriately.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifndef F_DUPFD_CLOEXEC
# define F_DUPFD_CLOEXEC 12
#endif
int
main (int argc, char *argv[])
{
if (argc > 1)
{
if (fcntl (3, F_GETFD) == 0)
{
puts ("descriptor not closed");
exit (1);
}
if (errno != EBADF)
{
puts ("error not EBADF");
exit (1);
}
exit (0);
}
int fd = fcntl (STDOUT_FILENO, F_DUPFD_CLOEXEC, 0);
if (fd == -1 && errno == EINVAL)
{
puts ("F_DUPFD_CLOEXEC not supported");
return 0;
}
if (fd != 3)
{
puts ("program called with descriptors other than 0,1,2");
return 1;
}
execl ("/proc/self/exe", "/proc/self/exe", "1", NULL);
puts ("execl failed");
return 1;
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Signed-off-by: Ulrich Drepper <drepper@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Cc: <linux-arch@vger.kernel.org>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-17 10:30:26 +04:00
case F_DUPFD_CLOEXEC :
2008-07-27 00:01:20 +04:00
if ( arg > = current - > signal - > rlim [ RLIMIT_NOFILE ] . rlim_cur )
break ;
2008-07-30 12:13:04 +04:00
err = alloc_fd ( arg , cmd = = F_DUPFD_CLOEXEC ? O_CLOEXEC : 0 ) ;
if ( err > = 0 ) {
get_file ( filp ) ;
fd_install ( err , filp ) ;
}
2005-04-17 02:20:36 +04:00
break ;
case F_GETFD :
err = get_close_on_exec ( fd ) ? FD_CLOEXEC : 0 ;
break ;
case F_SETFD :
err = 0 ;
set_close_on_exec ( fd , arg & FD_CLOEXEC ) ;
break ;
case F_GETFL :
err = filp - > f_flags ;
break ;
case F_SETFL :
err = setfl ( fd , filp , arg ) ;
break ;
case F_GETLK :
err = fcntl_getlk ( filp , ( struct flock __user * ) arg ) ;
break ;
case F_SETLK :
case F_SETLKW :
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
err = fcntl_setlk ( fd , filp , cmd , ( struct flock __user * ) arg ) ;
2005-04-17 02:20:36 +04:00
break ;
case F_GETOWN :
/*
* XXX If f_owner is a process group , the
* negative return value will get converted
* into an error . Oops . If we keep the
* current syscall conventions , the only way
* to fix this will be in libc .
*/
2006-10-02 13:17:15 +04:00
err = f_getown ( filp ) ;
2005-04-17 02:20:36 +04:00
force_successful_syscall_return ( ) ;
break ;
case F_SETOWN :
err = f_setown ( filp , arg , 1 ) ;
break ;
case F_GETSIG :
err = filp - > f_owner . signum ;
break ;
case F_SETSIG :
/* arg == 0 restores default behaviour. */
2005-05-01 19:59:14 +04:00
if ( ! valid_signal ( arg ) ) {
2005-04-17 02:20:36 +04:00
break ;
}
err = 0 ;
filp - > f_owner . signum = arg ;
break ;
case F_GETLEASE :
err = fcntl_getlease ( filp ) ;
break ;
case F_SETLEASE :
err = fcntl_setlease ( fd , filp , arg ) ;
break ;
case F_NOTIFY :
err = fcntl_dirnotify ( fd , filp , arg ) ;
break ;
default :
break ;
}
return err ;
}
asmlinkage long sys_fcntl ( unsigned int fd , unsigned int cmd , unsigned long arg )
{
struct file * filp ;
long err = - EBADF ;
filp = fget ( fd ) ;
if ( ! filp )
goto out ;
err = security_file_fcntl ( filp , cmd , arg ) ;
if ( err ) {
fput ( filp ) ;
return err ;
}
err = do_fcntl ( fd , cmd , arg , filp ) ;
fput ( filp ) ;
out :
return err ;
}
# if BITS_PER_LONG == 32
asmlinkage long sys_fcntl64 ( unsigned int fd , unsigned int cmd , unsigned long arg )
{
struct file * filp ;
long err ;
err = - EBADF ;
filp = fget ( fd ) ;
if ( ! filp )
goto out ;
err = security_file_fcntl ( filp , cmd , arg ) ;
if ( err ) {
fput ( filp ) ;
return err ;
}
err = - EBADF ;
switch ( cmd ) {
case F_GETLK64 :
err = fcntl_getlk64 ( filp , ( struct flock64 __user * ) arg ) ;
break ;
case F_SETLK64 :
case F_SETLKW64 :
[PATCH] stale POSIX lock handling
I believe that there is a problem with the handling of POSIX locks, which
the attached patch should address.
The problem appears to be a race between fcntl(2) and close(2). A
multithreaded application could close a file descriptor at the same time as
it is trying to acquire a lock using the same file descriptor. I would
suggest that that multithreaded application is not providing the proper
synchronization for itself, but the OS should still behave correctly.
SUS3 (Single UNIX Specification Version 3, read: POSIX) indicates that when
a file descriptor is closed, that all POSIX locks on the file, owned by the
process which closed the file descriptor, should be released.
The trick here is when those locks are released. The current code releases
all locks which exist when close is processing, but any locks in progress
are handled when the last reference to the open file is released.
There are three cases to consider.
One is the simple case, a multithreaded (mt) process has a file open and
races to close it and acquire a lock on it. In this case, the close will
release one reference to the open file and when the fcntl is done, it will
release the other reference. For this situation, no locks should exist on
the file when both the close and fcntl operations are done. The current
system will handle this case because the last reference to the open file is
being released.
The second case is when the mt process has dup(2)'d the file descriptor.
The close will release one reference to the file and the fcntl, when done,
will release another, but there will still be at least one more reference
to the open file. One could argue that the existence of a lock on the file
after the close has completed is okay, because it was acquired after the
close operation and there is still a way for the application to release the
lock on the file, using an existing file descriptor.
The third case is when the mt process has forked, after opening the file
and either before or after becoming an mt process. In this case, each
process would hold a reference to the open file. For each process, this
degenerates to first case above. However, the lock continues to exist
until both processes have released their references to the open file. This
lock could block other lock requests.
The changes to release the lock when the last reference to the open file
aren't quite right because they would allow the lock to exist as long as
there was a reference to the open file. This is too long.
The new proposed solution is to add support in the fcntl code path to
detect a race with close and then to release the lock which was just
acquired when such as race is detected. This causes locks to be released
in a timely fashion and for the system to conform to the POSIX semantic
specification.
This was tested by instrumenting a kernel to detect the handling locks and
then running a program which generates case #3 above. A dangling lock
could be reliably generated. When the changes to detect the close/fcntl
race were added, a dangling lock could no longer be generated.
Cc: Matthew Wilcox <willy@debian.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-27 22:45:09 +04:00
err = fcntl_setlk64 ( fd , filp , cmd ,
( struct flock64 __user * ) arg ) ;
2005-04-17 02:20:36 +04:00
break ;
default :
err = do_fcntl ( fd , cmd , arg , filp ) ;
break ;
}
fput ( filp ) ;
out :
return err ;
}
# endif
/* Table to convert sigio signal codes into poll band bitmaps */
2006-03-26 13:37:24 +04:00
static const long band_table [ NSIGPOLL ] = {
2005-04-17 02:20:36 +04:00
POLLIN | POLLRDNORM , /* POLL_IN */
POLLOUT | POLLWRNORM | POLLWRBAND , /* POLL_OUT */
POLLIN | POLLRDNORM | POLLMSG , /* POLL_MSG */
POLLERR , /* POLL_ERR */
POLLPRI | POLLRDBAND , /* POLL_PRI */
POLLHUP | POLLERR /* POLL_HUP */
} ;
static inline int sigio_perm ( struct task_struct * p ,
struct fown_struct * fown , int sig )
{
return ( ( ( fown - > euid = = 0 ) | |
2008-11-14 02:39:16 +03:00
( fown - > euid = = p - > cred - > suid ) | | ( fown - > euid = = p - > cred - > uid ) | |
( fown - > uid = = p - > cred - > suid ) | | ( fown - > uid = = p - > cred - > uid ) ) & &
2005-04-17 02:20:36 +04:00
! security_file_send_sigiotask ( p , fown , sig ) ) ;
}
static void send_sigio_to_task ( struct task_struct * p ,
struct fown_struct * fown ,
int fd ,
int reason )
{
if ( ! sigio_perm ( p , fown , fown - > signum ) )
return ;
switch ( fown - > signum ) {
siginfo_t si ;
default :
/* Queue a rt signal with the appropriate fd as its
value . We use SI_SIGIO as the source , not
SI_KERNEL , since kernel signals always get
delivered even if we can ' t queue . Failure to
queue in this case _should_ be reported ; we fall
back to SIGIO in that case . - - sct */
si . si_signo = fown - > signum ;
si . si_errno = 0 ;
si . si_code = reason ;
/* Make sure we are called with one of the POLL_*
reasons , otherwise we could leak kernel stack into
userspace . */
2006-04-02 15:37:19 +04:00
BUG_ON ( ( reason & __SI_MASK ) ! = __SI_POLL ) ;
2005-04-17 02:20:36 +04:00
if ( reason - POLL_IN > = NSIGPOLL )
si . si_band = ~ 0L ;
else
si . si_band = band_table [ reason - POLL_IN ] ;
si . si_fd = fd ;
2006-01-08 12:03:29 +03:00
if ( ! group_send_sig_info ( fown - > signum , & si , p ) )
2005-04-17 02:20:36 +04:00
break ;
/* fall-through: fall back on the old plain SIGIO signal */
case 0 :
2006-01-08 12:03:29 +03:00
group_send_sig_info ( SIGIO , SEND_SIG_PRIV , p ) ;
2005-04-17 02:20:36 +04:00
}
}
void send_sigio ( struct fown_struct * fown , int fd , int band )
{
struct task_struct * p ;
2006-10-02 13:17:15 +04:00
enum pid_type type ;
struct pid * pid ;
2005-04-17 02:20:36 +04:00
read_lock ( & fown - > lock ) ;
2006-10-02 13:17:15 +04:00
type = fown - > pid_type ;
2005-04-17 02:20:36 +04:00
pid = fown - > pid ;
if ( ! pid )
goto out_unlock_fown ;
read_lock ( & tasklist_lock ) ;
2006-10-02 13:17:15 +04:00
do_each_pid_task ( pid , type , p ) {
send_sigio_to_task ( p , fown , fd , band ) ;
} while_each_pid_task ( pid , type , p ) ;
2005-04-17 02:20:36 +04:00
read_unlock ( & tasklist_lock ) ;
out_unlock_fown :
read_unlock ( & fown - > lock ) ;
}
static void send_sigurg_to_task ( struct task_struct * p ,
struct fown_struct * fown )
{
if ( sigio_perm ( p , fown , SIGURG ) )
2006-01-08 12:03:29 +03:00
group_send_sig_info ( SIGURG , SEND_SIG_PRIV , p ) ;
2005-04-17 02:20:36 +04:00
}
int send_sigurg ( struct fown_struct * fown )
{
struct task_struct * p ;
2006-10-02 13:17:15 +04:00
enum pid_type type ;
struct pid * pid ;
int ret = 0 ;
2005-04-17 02:20:36 +04:00
read_lock ( & fown - > lock ) ;
2006-10-02 13:17:15 +04:00
type = fown - > pid_type ;
2005-04-17 02:20:36 +04:00
pid = fown - > pid ;
if ( ! pid )
goto out_unlock_fown ;
ret = 1 ;
read_lock ( & tasklist_lock ) ;
2006-10-02 13:17:15 +04:00
do_each_pid_task ( pid , type , p ) {
send_sigurg_to_task ( p , fown ) ;
} while_each_pid_task ( pid , type , p ) ;
2005-04-17 02:20:36 +04:00
read_unlock ( & tasklist_lock ) ;
out_unlock_fown :
read_unlock ( & fown - > lock ) ;
return ret ;
}
static DEFINE_RWLOCK ( fasync_lock ) ;
2006-12-07 07:33:20 +03:00
static struct kmem_cache * fasync_cache __read_mostly ;
2005-04-17 02:20:36 +04:00
/*
* fasync_helper ( ) is used by some character device drivers ( mainly mice )
* to set up the fasync queue . It returns negative on error , 0 if it did
* no changes and positive if it added / deleted the entry .
*/
int fasync_helper ( int fd , struct file * filp , int on , struct fasync_struct * * fapp )
{
struct fasync_struct * fa , * * fp ;
struct fasync_struct * new = NULL ;
int result = 0 ;
if ( on ) {
2006-12-07 07:33:17 +03:00
new = kmem_cache_alloc ( fasync_cache , GFP_KERNEL ) ;
2005-04-17 02:20:36 +04:00
if ( ! new )
return - ENOMEM ;
}
write_lock_irq ( & fasync_lock ) ;
for ( fp = fapp ; ( fa = * fp ) ! = NULL ; fp = & fa - > fa_next ) {
if ( fa - > fa_file = = filp ) {
if ( on ) {
fa - > fa_fd = fd ;
kmem_cache_free ( fasync_cache , new ) ;
} else {
* fp = fa - > fa_next ;
kmem_cache_free ( fasync_cache , fa ) ;
result = 1 ;
}
goto out ;
}
}
if ( on ) {
new - > magic = FASYNC_MAGIC ;
new - > fa_file = filp ;
new - > fa_fd = fd ;
new - > fa_next = * fapp ;
* fapp = new ;
result = 1 ;
}
out :
write_unlock_irq ( & fasync_lock ) ;
return result ;
}
EXPORT_SYMBOL ( fasync_helper ) ;
void __kill_fasync ( struct fasync_struct * fa , int sig , int band )
{
while ( fa ) {
struct fown_struct * fown ;
if ( fa - > magic ! = FASYNC_MAGIC ) {
printk ( KERN_ERR " kill_fasync: bad magic number in "
" fasync_struct! \n " ) ;
return ;
}
fown = & fa - > fa_file - > f_owner ;
/* Don't send SIGURG to processes which have not set a
queued signum : SIGURG has its own default signalling
mechanism . */
if ( ! ( sig = = SIGURG & & fown - > signum = = 0 ) )
send_sigio ( fown , fa - > fa_fd , band ) ;
fa = fa - > fa_next ;
}
}
EXPORT_SYMBOL ( __kill_fasync ) ;
void kill_fasync ( struct fasync_struct * * fp , int sig , int band )
{
/* First a quick test without locking: usually
* the list is empty .
*/
if ( * fp ) {
read_lock ( & fasync_lock ) ;
/* reread *fp after obtaining the lock */
__kill_fasync ( * fp , sig , band ) ;
read_unlock ( & fasync_lock ) ;
}
}
EXPORT_SYMBOL ( kill_fasync ) ;
static int __init fasync_init ( void )
{
fasync_cache = kmem_cache_create ( " fasync_cache " ,
2007-07-20 05:11:58 +04:00
sizeof ( struct fasync_struct ) , 0 , SLAB_PANIC , NULL ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
module_init ( fasync_init )