blob: 452d02f9075ea19861d6d6bd00de12afd19a65eb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/fcntl.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7#include <linux/syscalls.h>
8#include <linux/init.h>
9#include <linux/mm.h>
10#include <linux/fs.h>
11#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040012#include <linux/fdtable.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080013#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/dnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/slab.h>
16#include <linux/module.h>
17#include <linux/security.h>
18#include <linux/ptrace.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070019#include <linux/signal.h>
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070020#include <linux/rcupdate.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070021#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#include <asm/poll.h>
24#include <asm/siginfo.h>
25#include <asm/uaccess.h>
26
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -080027void set_close_on_exec(unsigned int fd, int flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
29 struct files_struct *files = current->files;
Dipankar Sarmabadf1662005-09-09 13:04:10 -070030 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 spin_lock(&files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -070032 fdt = files_fdtable(files);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 if (flag)
Dipankar Sarmabadf1662005-09-09 13:04:10 -070034 FD_SET(fd, fdt->close_on_exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 else
Dipankar Sarmabadf1662005-09-09 13:04:10 -070036 FD_CLR(fd, fdt->close_on_exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 spin_unlock(&files->file_lock);
38}
39
Arjan van de Ven858119e2006-01-14 13:20:43 -080040static int get_close_on_exec(unsigned int fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
42 struct files_struct *files = current->files;
Dipankar Sarmabadf1662005-09-09 13:04:10 -070043 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 int res;
Dipankar Sarmab8359962005-09-09 13:04:14 -070045 rcu_read_lock();
Dipankar Sarmabadf1662005-09-09 13:04:10 -070046 fdt = files_fdtable(files);
47 res = FD_ISSET(fd, fdt->close_on_exec);
Dipankar Sarmab8359962005-09-09 13:04:14 -070048 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 return res;
50}
51
Heiko Carstensa26eab22009-01-14 14:14:17 +010052SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
54 int err = -EBADF;
55 struct file * file, *tofree;
56 struct files_struct * files = current->files;
Dipankar Sarmabadf1662005-09-09 13:04:10 -070057 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Ulrich Drepper336dd1f2008-07-23 21:29:29 -070059 if ((flags & ~O_CLOEXEC) != 0)
60 return -EINVAL;
61
Al Viro6c5d0512008-07-26 13:38:19 -040062 if (unlikely(oldfd == newfd))
63 return -EINVAL;
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 spin_lock(&files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 err = expand_files(files, newfd);
Al Viro1b7e1902008-07-30 06:18:03 -040067 file = fcheck(oldfd);
68 if (unlikely(!file))
69 goto Ebadf;
Al Viro4e1e0182008-07-26 16:01:20 -040070 if (unlikely(err < 0)) {
71 if (err == -EMFILE)
Al Viro1b7e1902008-07-30 06:18:03 -040072 goto Ebadf;
73 goto out_unlock;
Al Viro4e1e0182008-07-26 16:01:20 -040074 }
Al Viro1b7e1902008-07-30 06:18:03 -040075 /*
76 * We need to detect attempts to do dup2() over allocated but still
77 * not finished descriptor. NB: OpenBSD avoids that at the price of
78 * extra work in their equivalent of fget() - they insert struct
79 * file immediately after grabbing descriptor, mark it larval if
80 * more work (e.g. actual opening) is needed and make sure that
81 * fget() treats larval files as absent. Potentially interesting,
82 * but while extra work in fget() is trivial, locking implications
83 * and amount of surgery on open()-related paths in VFS are not.
84 * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
85 * deadlocks in rather amusing ways, AFAICS. All of that is out of
86 * scope of POSIX or SUS, since neither considers shared descriptor
87 * tables and this condition does not arise without those.
88 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 err = -EBUSY;
Dipankar Sarmabadf1662005-09-09 13:04:10 -070090 fdt = files_fdtable(files);
91 tofree = fdt->fd[newfd];
92 if (!tofree && FD_ISSET(newfd, fdt->open_fds))
Al Viro1b7e1902008-07-30 06:18:03 -040093 goto out_unlock;
94 get_file(file);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070095 rcu_assign_pointer(fdt->fd[newfd], file);
Dipankar Sarmabadf1662005-09-09 13:04:10 -070096 FD_SET(newfd, fdt->open_fds);
Ulrich Drepper336dd1f2008-07-23 21:29:29 -070097 if (flags & O_CLOEXEC)
98 FD_SET(newfd, fdt->close_on_exec);
99 else
100 FD_CLR(newfd, fdt->close_on_exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 spin_unlock(&files->file_lock);
102
103 if (tofree)
104 filp_close(tofree, files);
Al Viro1b7e1902008-07-30 06:18:03 -0400105
106 return newfd;
107
108Ebadf:
109 err = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110out_unlock:
111 spin_unlock(&files->file_lock);
Al Viro1b7e1902008-07-30 06:18:03 -0400112 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
Heiko Carstensa26eab22009-01-14 14:14:17 +0100115SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
Ulrich Drepper336dd1f2008-07-23 21:29:29 -0700116{
Al Viro6c5d0512008-07-26 13:38:19 -0400117 if (unlikely(newfd == oldfd)) { /* corner case */
118 struct files_struct *files = current->files;
Jeff Mahoney2b79bc42009-05-11 14:25:34 -0400119 int retval = oldfd;
120
Al Viro6c5d0512008-07-26 13:38:19 -0400121 rcu_read_lock();
122 if (!fcheck_files(files, oldfd))
Jeff Mahoney2b79bc42009-05-11 14:25:34 -0400123 retval = -EBADF;
Al Viro6c5d0512008-07-26 13:38:19 -0400124 rcu_read_unlock();
Jeff Mahoney2b79bc42009-05-11 14:25:34 -0400125 return retval;
Al Viro6c5d0512008-07-26 13:38:19 -0400126 }
Ulrich Drepper336dd1f2008-07-23 21:29:29 -0700127 return sys_dup3(oldfd, newfd, 0);
128}
129
Heiko Carstensa26eab22009-01-14 14:14:17 +0100130SYSCALL_DEFINE1(dup, unsigned int, fildes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
132 int ret = -EBADF;
Al Viro1027abe2008-07-30 04:13:04 -0400133 struct file *file = fget(fildes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Al Viro1027abe2008-07-30 04:13:04 -0400135 if (file) {
136 ret = get_unused_fd();
137 if (ret >= 0)
138 fd_install(ret, file);
139 else
140 fput(file);
141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return ret;
143}
144
Jonathan Corbet76398422009-02-01 14:26:59 -0700145#define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147static int setfl(int fd, struct file * filp, unsigned long arg)
148{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800149 struct inode * inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 int error = 0;
151
dean gaudet7d95c8f2006-02-03 03:04:30 -0800152 /*
153 * O_APPEND cannot be cleared if the file is marked as append-only
154 * and the file is open for write.
155 */
156 if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 return -EPERM;
158
159 /* O_NOATIME can only be set by the owner or superuser */
160 if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
Satyam Sharma3bd858a2007-07-17 15:00:08 +0530161 if (!is_owner_or_cap(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return -EPERM;
163
164 /* required for strict SunOS emulation */
165 if (O_NONBLOCK != O_NDELAY)
166 if (arg & O_NDELAY)
167 arg |= O_NONBLOCK;
168
169 if (arg & O_DIRECT) {
170 if (!filp->f_mapping || !filp->f_mapping->a_ops ||
171 !filp->f_mapping->a_ops->direct_IO)
172 return -EINVAL;
173 }
174
175 if (filp->f_op && filp->f_op->check_flags)
176 error = filp->f_op->check_flags(arg);
177 if (error)
178 return error;
179
Jonathan Corbet218d11a2008-12-05 16:12:48 -0700180 /*
Jonathan Corbet76398422009-02-01 14:26:59 -0700181 * ->fasync() is responsible for setting the FASYNC bit.
Jonathan Corbet218d11a2008-12-05 16:12:48 -0700182 */
Jonathan Corbet76398422009-02-01 14:26:59 -0700183 if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
184 filp->f_op->fasync) {
185 error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
186 if (error < 0)
187 goto out;
Jonathan Corbet60aa4922009-02-01 14:52:56 -0700188 if (error > 0)
189 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -0700191 spin_lock(&filp->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -0700193 spin_unlock(&filp->f_lock);
Jonathan Corbet76398422009-02-01 14:26:59 -0700194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 return error;
197}
198
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700199static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
Oleg Nesterov2f38d702009-06-16 22:07:46 +0200200 int force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Linus Torvalds80e1e822010-02-07 10:11:23 -0800202 write_lock_irq(&filp->f_owner.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 if (force || !filp->f_owner.pid) {
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700204 put_pid(filp->f_owner.pid);
205 filp->f_owner.pid = get_pid(pid);
206 filp->f_owner.pid_type = type;
Oleg Nesterov2f38d702009-06-16 22:07:46 +0200207
208 if (pid) {
209 const struct cred *cred = current_cred();
210 filp->f_owner.uid = cred->uid;
211 filp->f_owner.euid = cred->euid;
212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 }
Linus Torvalds80e1e822010-02-07 10:11:23 -0800214 write_unlock_irq(&filp->f_owner.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700217int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
218 int force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 int err;
Oleg Nesterov2f38d702009-06-16 22:07:46 +0200221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 err = security_file_set_fowner(filp);
223 if (err)
224 return err;
225
Oleg Nesterov2f38d702009-06-16 22:07:46 +0200226 f_modown(filp, pid, type, force);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return 0;
228}
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700229EXPORT_SYMBOL(__f_setown);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700231int f_setown(struct file *filp, unsigned long arg, int force)
232{
233 enum pid_type type;
234 struct pid *pid;
235 int who = arg;
236 int result;
237 type = PIDTYPE_PID;
238 if (who < 0) {
239 type = PIDTYPE_PGID;
240 who = -who;
241 }
242 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700243 pid = find_vpid(who);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700244 result = __f_setown(filp, pid, type, force);
245 rcu_read_unlock();
246 return result;
247}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248EXPORT_SYMBOL(f_setown);
249
250void f_delown(struct file *filp)
251{
Oleg Nesterov2f38d702009-06-16 22:07:46 +0200252 f_modown(filp, NULL, PIDTYPE_PID, 1);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700253}
254
255pid_t f_getown(struct file *filp)
256{
257 pid_t pid;
Eric W. Biederman43fa1ad2006-10-02 02:17:27 -0700258 read_lock(&filp->f_owner.lock);
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -0800259 pid = pid_vnr(filp->f_owner.pid);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700260 if (filp->f_owner.pid_type == PIDTYPE_PGID)
261 pid = -pid;
Eric W. Biederman43fa1ad2006-10-02 02:17:27 -0700262 read_unlock(&filp->f_owner.lock);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700263 return pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700266static int f_setown_ex(struct file *filp, unsigned long arg)
267{
268 struct f_owner_ex * __user owner_p = (void * __user)arg;
269 struct f_owner_ex owner;
270 struct pid *pid;
271 int type;
272 int ret;
273
274 ret = copy_from_user(&owner, owner_p, sizeof(owner));
275 if (ret)
276 return ret;
277
278 switch (owner.type) {
279 case F_OWNER_TID:
280 type = PIDTYPE_MAX;
281 break;
282
283 case F_OWNER_PID:
284 type = PIDTYPE_PID;
285 break;
286
Peter Zijlstra978b4052009-11-17 14:06:24 -0800287 case F_OWNER_PGRP:
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700288 type = PIDTYPE_PGID;
289 break;
290
291 default:
292 return -EINVAL;
293 }
294
295 rcu_read_lock();
296 pid = find_vpid(owner.pid);
297 if (owner.pid && !pid)
298 ret = -ESRCH;
299 else
300 ret = __f_setown(filp, pid, type, 1);
301 rcu_read_unlock();
302
303 return ret;
304}
305
306static int f_getown_ex(struct file *filp, unsigned long arg)
307{
308 struct f_owner_ex * __user owner_p = (void * __user)arg;
309 struct f_owner_ex owner;
310 int ret = 0;
311
312 read_lock(&filp->f_owner.lock);
313 owner.pid = pid_vnr(filp->f_owner.pid);
314 switch (filp->f_owner.pid_type) {
315 case PIDTYPE_MAX:
316 owner.type = F_OWNER_TID;
317 break;
318
319 case PIDTYPE_PID:
320 owner.type = F_OWNER_PID;
321 break;
322
323 case PIDTYPE_PGID:
Peter Zijlstra978b4052009-11-17 14:06:24 -0800324 owner.type = F_OWNER_PGRP;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700325 break;
326
327 default:
328 WARN_ON(1);
329 ret = -EINVAL;
330 break;
331 }
332 read_unlock(&filp->f_owner.lock);
333
334 if (!ret)
335 ret = copy_to_user(owner_p, &owner, sizeof(owner));
336 return ret;
337}
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
340 struct file *filp)
341{
342 long err = -EINVAL;
343
344 switch (cmd) {
345 case F_DUPFD:
Ulrich Drepper22d2b352007-10-16 23:30:26 -0700346 case F_DUPFD_CLOEXEC:
Jiri Slabyd554ed892010-03-05 13:42:42 -0800347 if (arg >= rlimit(RLIMIT_NOFILE))
Al Viro4e1e0182008-07-26 16:01:20 -0400348 break;
Al Viro1027abe2008-07-30 04:13:04 -0400349 err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
350 if (err >= 0) {
351 get_file(filp);
352 fd_install(err, filp);
353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 break;
355 case F_GETFD:
356 err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
357 break;
358 case F_SETFD:
359 err = 0;
360 set_close_on_exec(fd, arg & FD_CLOEXEC);
361 break;
362 case F_GETFL:
363 err = filp->f_flags;
364 break;
365 case F_SETFL:
366 err = setfl(fd, filp, arg);
367 break;
368 case F_GETLK:
369 err = fcntl_getlk(filp, (struct flock __user *) arg);
370 break;
371 case F_SETLK:
372 case F_SETLKW:
Peter Staubachc2936212005-07-27 11:45:09 -0700373 err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 break;
375 case F_GETOWN:
376 /*
377 * XXX If f_owner is a process group, the
378 * negative return value will get converted
379 * into an error. Oops. If we keep the
380 * current syscall conventions, the only way
381 * to fix this will be in libc.
382 */
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700383 err = f_getown(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 force_successful_syscall_return();
385 break;
386 case F_SETOWN:
387 err = f_setown(filp, arg, 1);
388 break;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700389 case F_GETOWN_EX:
390 err = f_getown_ex(filp, arg);
391 break;
392 case F_SETOWN_EX:
393 err = f_setown_ex(filp, arg);
394 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 case F_GETSIG:
396 err = filp->f_owner.signum;
397 break;
398 case F_SETSIG:
399 /* arg == 0 restores default behaviour. */
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700400 if (!valid_signal(arg)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 break;
402 }
403 err = 0;
404 filp->f_owner.signum = arg;
405 break;
406 case F_GETLEASE:
407 err = fcntl_getlease(filp);
408 break;
409 case F_SETLEASE:
410 err = fcntl_setlease(fd, filp, arg);
411 break;
412 case F_NOTIFY:
413 err = fcntl_dirnotify(fd, filp, arg);
414 break;
415 default:
416 break;
417 }
418 return err;
419}
420
Heiko Carstensa26eab22009-01-14 14:14:17 +0100421SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 struct file *filp;
424 long err = -EBADF;
425
426 filp = fget(fd);
427 if (!filp)
428 goto out;
429
430 err = security_file_fcntl(filp, cmd, arg);
431 if (err) {
432 fput(filp);
433 return err;
434 }
435
436 err = do_fcntl(fd, cmd, arg, filp);
437
438 fput(filp);
439out:
440 return err;
441}
442
443#if BITS_PER_LONG == 32
Heiko Carstensa26eab22009-01-14 14:14:17 +0100444SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
445 unsigned long, arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
447 struct file * filp;
448 long err;
449
450 err = -EBADF;
451 filp = fget(fd);
452 if (!filp)
453 goto out;
454
455 err = security_file_fcntl(filp, cmd, arg);
456 if (err) {
457 fput(filp);
458 return err;
459 }
460 err = -EBADF;
461
462 switch (cmd) {
463 case F_GETLK64:
464 err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
465 break;
466 case F_SETLK64:
467 case F_SETLKW64:
Peter Staubachc2936212005-07-27 11:45:09 -0700468 err = fcntl_setlk64(fd, filp, cmd,
469 (struct flock64 __user *) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 break;
471 default:
472 err = do_fcntl(fd, cmd, arg, filp);
473 break;
474 }
475 fput(filp);
476out:
477 return err;
478}
479#endif
480
481/* Table to convert sigio signal codes into poll band bitmaps */
482
Eric Dumazetfa3536c2006-03-26 01:37:24 -0800483static const long band_table[NSIGPOLL] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 POLLIN | POLLRDNORM, /* POLL_IN */
485 POLLOUT | POLLWRNORM | POLLWRBAND, /* POLL_OUT */
486 POLLIN | POLLRDNORM | POLLMSG, /* POLL_MSG */
487 POLLERR, /* POLL_ERR */
488 POLLPRI | POLLRDBAND, /* POLL_PRI */
489 POLLHUP | POLLERR /* POLL_HUP */
490};
491
492static inline int sigio_perm(struct task_struct *p,
493 struct fown_struct *fown, int sig)
494{
David Howellsc69e8d92008-11-14 10:39:19 +1100495 const struct cred *cred;
496 int ret;
497
498 rcu_read_lock();
499 cred = __task_cred(p);
500 ret = ((fown->euid == 0 ||
501 fown->euid == cred->suid || fown->euid == cred->uid ||
502 fown->uid == cred->suid || fown->uid == cred->uid) &&
503 !security_file_send_sigiotask(p, fown, sig));
504 rcu_read_unlock();
505 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506}
507
508static void send_sigio_to_task(struct task_struct *p,
Oleg Nesterov8eeee4e2009-06-17 00:27:10 +0200509 struct fown_struct *fown,
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700510 int fd, int reason, int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Oleg Nesterov8eeee4e2009-06-17 00:27:10 +0200512 /*
513 * F_SETSIG can change ->signum lockless in parallel, make
514 * sure we read it once and use the same value throughout.
515 */
516 int signum = ACCESS_ONCE(fown->signum);
517
518 if (!sigio_perm(p, fown, signum))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return;
520
Oleg Nesterov8eeee4e2009-06-17 00:27:10 +0200521 switch (signum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 siginfo_t si;
523 default:
524 /* Queue a rt signal with the appropriate fd as its
525 value. We use SI_SIGIO as the source, not
526 SI_KERNEL, since kernel signals always get
527 delivered even if we can't queue. Failure to
528 queue in this case _should_ be reported; we fall
529 back to SIGIO in that case. --sct */
Oleg Nesterov8eeee4e2009-06-17 00:27:10 +0200530 si.si_signo = signum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 si.si_errno = 0;
532 si.si_code = reason;
533 /* Make sure we are called with one of the POLL_*
534 reasons, otherwise we could leak kernel stack into
535 userspace. */
Eric Sesterhennf6298aa2006-04-02 13:37:19 +0200536 BUG_ON((reason & __SI_MASK) != __SI_POLL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 if (reason - POLL_IN >= NSIGPOLL)
538 si.si_band = ~0L;
539 else
540 si.si_band = band_table[reason - POLL_IN];
541 si.si_fd = fd;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700542 if (!do_send_sig_info(signum, &si, p, group))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 break;
544 /* fall-through: fall back on the old plain SIGIO signal */
545 case 0:
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700546 do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 }
548}
549
550void send_sigio(struct fown_struct *fown, int fd, int band)
551{
552 struct task_struct *p;
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700553 enum pid_type type;
554 struct pid *pid;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700555 int group = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 read_lock(&fown->lock);
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700558
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700559 type = fown->pid_type;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700560 if (type == PIDTYPE_MAX) {
561 group = 0;
562 type = PIDTYPE_PID;
563 }
564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 pid = fown->pid;
566 if (!pid)
567 goto out_unlock_fown;
568
569 read_lock(&tasklist_lock);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700570 do_each_pid_task(pid, type, p) {
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700571 send_sigio_to_task(p, fown, fd, band, group);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700572 } while_each_pid_task(pid, type, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 read_unlock(&tasklist_lock);
574 out_unlock_fown:
575 read_unlock(&fown->lock);
576}
577
578static void send_sigurg_to_task(struct task_struct *p,
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700579 struct fown_struct *fown, int group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 if (sigio_perm(p, fown, SIGURG))
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700582 do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583}
584
585int send_sigurg(struct fown_struct *fown)
586{
587 struct task_struct *p;
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700588 enum pid_type type;
589 struct pid *pid;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700590 int group = 1;
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700591 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 read_lock(&fown->lock);
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700594
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700595 type = fown->pid_type;
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700596 if (type == PIDTYPE_MAX) {
597 group = 0;
598 type = PIDTYPE_PID;
599 }
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 pid = fown->pid;
602 if (!pid)
603 goto out_unlock_fown;
604
605 ret = 1;
606
607 read_lock(&tasklist_lock);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700608 do_each_pid_task(pid, type, p) {
Peter Zijlstraba0a6c92009-09-23 15:57:03 -0700609 send_sigurg_to_task(p, fown, group);
Eric W. Biederman609d7fa2006-10-02 02:17:15 -0700610 } while_each_pid_task(pid, type, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 read_unlock(&tasklist_lock);
612 out_unlock_fown:
613 read_unlock(&fown->lock);
614 return ret;
615}
616
617static DEFINE_RWLOCK(fasync_lock);
Christoph Lametere18b8902006-12-06 20:33:20 -0800618static struct kmem_cache *fasync_cache __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620/*
Linus Torvalds53281b62009-12-16 08:23:37 -0800621 * Remove a fasync entry. If successfully removed, return
622 * positive and clear the FASYNC flag. If no entry exists,
623 * do nothing and return 0.
624 *
625 * NOTE! It is very important that the FASYNC flag always
626 * match the state "is the filp on a fasync list".
627 *
628 * We always take the 'filp->f_lock', in since fasync_lock
629 * needs to be irq-safe.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 */
Linus Torvalds53281b62009-12-16 08:23:37 -0800631static int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
633 struct fasync_struct *fa, **fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 int result = 0;
635
Jonathan Corbet4a6a4492009-03-27 12:24:31 -0600636 spin_lock(&filp->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 write_lock_irq(&fasync_lock);
638 for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
Linus Torvalds53281b62009-12-16 08:23:37 -0800639 if (fa->fa_file != filp)
640 continue;
641 *fp = fa->fa_next;
642 kmem_cache_free(fasync_cache, fa);
Jonathan Corbet76398422009-02-01 14:26:59 -0700643 filp->f_flags &= ~FASYNC;
Linus Torvalds53281b62009-12-16 08:23:37 -0800644 result = 1;
645 break;
646 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 write_unlock_irq(&fasync_lock);
Jonathan Corbet4a6a4492009-03-27 12:24:31 -0600648 spin_unlock(&filp->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 return result;
650}
651
Linus Torvalds53281b62009-12-16 08:23:37 -0800652/*
653 * Add a fasync entry. Return negative on error, positive if
654 * added, and zero if did nothing but change an existing one.
655 *
656 * NOTE! It is very important that the FASYNC flag always
657 * match the state "is the filp on a fasync list".
658 */
659static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
660{
661 struct fasync_struct *new, *fa, **fp;
662 int result = 0;
663
664 new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
665 if (!new)
666 return -ENOMEM;
667
668 spin_lock(&filp->f_lock);
669 write_lock_irq(&fasync_lock);
670 for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
671 if (fa->fa_file != filp)
672 continue;
673 fa->fa_fd = fd;
674 kmem_cache_free(fasync_cache, new);
675 goto out;
676 }
677
678 new->magic = FASYNC_MAGIC;
679 new->fa_file = filp;
680 new->fa_fd = fd;
681 new->fa_next = *fapp;
682 *fapp = new;
683 result = 1;
684 filp->f_flags |= FASYNC;
685
686out:
687 write_unlock_irq(&fasync_lock);
688 spin_unlock(&filp->f_lock);
689 return result;
690}
691
692/*
693 * fasync_helper() is used by almost all character device drivers
694 * to set up the fasync queue, and for regular files by the file
695 * lease code. It returns negative on error, 0 if it did no changes
696 * and positive if it added/deleted the entry.
697 */
698int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
699{
700 if (!on)
701 return fasync_remove_entry(filp, fapp);
702 return fasync_add_entry(fd, filp, fapp);
703}
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705EXPORT_SYMBOL(fasync_helper);
706
707void __kill_fasync(struct fasync_struct *fa, int sig, int band)
708{
709 while (fa) {
710 struct fown_struct * fown;
711 if (fa->magic != FASYNC_MAGIC) {
712 printk(KERN_ERR "kill_fasync: bad magic number in "
713 "fasync_struct!\n");
714 return;
715 }
716 fown = &fa->fa_file->f_owner;
717 /* Don't send SIGURG to processes which have not set a
718 queued signum: SIGURG has its own default signalling
719 mechanism. */
720 if (!(sig == SIGURG && fown->signum == 0))
721 send_sigio(fown, fa->fa_fd, band);
722 fa = fa->fa_next;
723 }
724}
725
726EXPORT_SYMBOL(__kill_fasync);
727
728void kill_fasync(struct fasync_struct **fp, int sig, int band)
729{
730 /* First a quick test without locking: usually
731 * the list is empty.
732 */
733 if (*fp) {
734 read_lock(&fasync_lock);
735 /* reread *fp after obtaining the lock */
736 __kill_fasync(*fp, sig, band);
737 read_unlock(&fasync_lock);
738 }
739}
740EXPORT_SYMBOL(kill_fasync);
741
742static int __init fasync_init(void)
743{
744 fasync_cache = kmem_cache_create("fasync_cache",
Paul Mundt20c2df82007-07-20 10:11:58 +0900745 sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 return 0;
747}
748
749module_init(fasync_init)