F_DUPFD_CLOEXEC implementation
[linux-2.6.git] / fs / fcntl.c
1 /*
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>
12 #include <linux/capability.h>
13 #include <linux/dnotify.h>
14 #include <linux/smp_lock.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/security.h>
18 #include <linux/ptrace.h>
19 #include <linux/signal.h>
20 #include <linux/rcupdate.h>
21
22 #include <asm/poll.h>
23 #include <asm/siginfo.h>
24 #include <asm/uaccess.h>
25
26 void fastcall set_close_on_exec(unsigned int fd, int flag)
27 {
28         struct files_struct *files = current->files;
29         struct fdtable *fdt;
30         spin_lock(&files->file_lock);
31         fdt = files_fdtable(files);
32         if (flag)
33                 FD_SET(fd, fdt->close_on_exec);
34         else
35                 FD_CLR(fd, fdt->close_on_exec);
36         spin_unlock(&files->file_lock);
37 }
38
39 static int get_close_on_exec(unsigned int fd)
40 {
41         struct files_struct *files = current->files;
42         struct fdtable *fdt;
43         int res;
44         rcu_read_lock();
45         fdt = files_fdtable(files);
46         res = FD_ISSET(fd, fdt->close_on_exec);
47         rcu_read_unlock();
48         return res;
49 }
50
51 /*
52  * locate_fd finds a free file descriptor in the open_fds fdset,
53  * expanding the fd arrays if necessary.  Must be called with the
54  * file_lock held for write.
55  */
56
57 static int locate_fd(struct files_struct *files, 
58                             struct file *file, unsigned int orig_start)
59 {
60         unsigned int newfd;
61         unsigned int start;
62         int error;
63         struct fdtable *fdt;
64
65         error = -EINVAL;
66         if (orig_start >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
67                 goto out;
68
69 repeat:
70         fdt = files_fdtable(files);
71         /*
72          * Someone might have closed fd's in the range
73          * orig_start..fdt->next_fd
74          */
75         start = orig_start;
76         if (start < files->next_fd)
77                 start = files->next_fd;
78
79         newfd = start;
80         if (start < fdt->max_fds)
81                 newfd = find_next_zero_bit(fdt->open_fds->fds_bits,
82                                            fdt->max_fds, start);
83         
84         error = -EMFILE;
85         if (newfd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
86                 goto out;
87
88         error = expand_files(files, newfd);
89         if (error < 0)
90                 goto out;
91
92         /*
93          * If we needed to expand the fs array we
94          * might have blocked - try again.
95          */
96         if (error)
97                 goto repeat;
98
99         /*
100          * We reacquired files_lock, so we are safe as long as
101          * we reacquire the fdtable pointer and use it while holding
102          * the lock, no one can free it during that time.
103          */
104         if (start <= files->next_fd)
105                 files->next_fd = newfd + 1;
106
107         error = newfd;
108         
109 out:
110         return error;
111 }
112
113 static int dupfd(struct file *file, unsigned int start, int cloexec)
114 {
115         struct files_struct * files = current->files;
116         struct fdtable *fdt;
117         int fd;
118
119         spin_lock(&files->file_lock);
120         fd = locate_fd(files, file, start);
121         if (fd >= 0) {
122                 /* locate_fd() may have expanded fdtable, load the ptr */
123                 fdt = files_fdtable(files);
124                 FD_SET(fd, fdt->open_fds);
125                 if (cloexec)
126                         FD_SET(fd, fdt->close_on_exec);
127                 else
128                         FD_CLR(fd, fdt->close_on_exec);
129                 spin_unlock(&files->file_lock);
130                 fd_install(fd, file);
131         } else {
132                 spin_unlock(&files->file_lock);
133                 fput(file);
134         }
135
136         return fd;
137 }
138
139 asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd)
140 {
141         int err = -EBADF;
142         struct file * file, *tofree;
143         struct files_struct * files = current->files;
144         struct fdtable *fdt;
145
146         spin_lock(&files->file_lock);
147         if (!(file = fcheck(oldfd)))
148                 goto out_unlock;
149         err = newfd;
150         if (newfd == oldfd)
151                 goto out_unlock;
152         err = -EBADF;
153         if (newfd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
154                 goto out_unlock;
155         get_file(file);                 /* We are now finished with oldfd */
156
157         err = expand_files(files, newfd);
158         if (err < 0)
159                 goto out_fput;
160
161         /* To avoid races with open() and dup(), we will mark the fd as
162          * in-use in the open-file bitmap throughout the entire dup2()
163          * process.  This is quite safe: do_close() uses the fd array
164          * entry, not the bitmap, to decide what work needs to be
165          * done.  --sct */
166         /* Doesn't work. open() might be there first. --AV */
167
168         /* Yes. It's a race. In user space. Nothing sane to do */
169         err = -EBUSY;
170         fdt = files_fdtable(files);
171         tofree = fdt->fd[newfd];
172         if (!tofree && FD_ISSET(newfd, fdt->open_fds))
173                 goto out_fput;
174
175         rcu_assign_pointer(fdt->fd[newfd], file);
176         FD_SET(newfd, fdt->open_fds);
177         FD_CLR(newfd, fdt->close_on_exec);
178         spin_unlock(&files->file_lock);
179
180         if (tofree)
181                 filp_close(tofree, files);
182         err = newfd;
183 out:
184         return err;
185 out_unlock:
186         spin_unlock(&files->file_lock);
187         goto out;
188
189 out_fput:
190         spin_unlock(&files->file_lock);
191         fput(file);
192         goto out;
193 }
194
195 asmlinkage long sys_dup(unsigned int fildes)
196 {
197         int ret = -EBADF;
198         struct file * file = fget(fildes);
199
200         if (file)
201                 ret = dupfd(file, 0, 0);
202         return ret;
203 }
204
205 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | FASYNC | O_DIRECT | O_NOATIME)
206
207 static int setfl(int fd, struct file * filp, unsigned long arg)
208 {
209         struct inode * inode = filp->f_path.dentry->d_inode;
210         int error = 0;
211
212         /*
213          * O_APPEND cannot be cleared if the file is marked as append-only
214          * and the file is open for write.
215          */
216         if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
217                 return -EPERM;
218
219         /* O_NOATIME can only be set by the owner or superuser */
220         if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
221                 if (!is_owner_or_cap(inode))
222                         return -EPERM;
223
224         /* required for strict SunOS emulation */
225         if (O_NONBLOCK != O_NDELAY)
226                if (arg & O_NDELAY)
227                    arg |= O_NONBLOCK;
228
229         if (arg & O_DIRECT) {
230                 if (!filp->f_mapping || !filp->f_mapping->a_ops ||
231                         !filp->f_mapping->a_ops->direct_IO)
232                                 return -EINVAL;
233         }
234
235         if (filp->f_op && filp->f_op->check_flags)
236                 error = filp->f_op->check_flags(arg);
237         if (error)
238                 return error;
239
240         lock_kernel();
241         if ((arg ^ filp->f_flags) & FASYNC) {
242                 if (filp->f_op && filp->f_op->fasync) {
243                         error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
244                         if (error < 0)
245                                 goto out;
246                 }
247         }
248
249         filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
250  out:
251         unlock_kernel();
252         return error;
253 }
254
255 static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
256                      uid_t uid, uid_t euid, int force)
257 {
258         write_lock_irq(&filp->f_owner.lock);
259         if (force || !filp->f_owner.pid) {
260                 put_pid(filp->f_owner.pid);
261                 filp->f_owner.pid = get_pid(pid);
262                 filp->f_owner.pid_type = type;
263                 filp->f_owner.uid = uid;
264                 filp->f_owner.euid = euid;
265         }
266         write_unlock_irq(&filp->f_owner.lock);
267 }
268
269 int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
270                 int force)
271 {
272         int err;
273         
274         err = security_file_set_fowner(filp);
275         if (err)
276                 return err;
277
278         f_modown(filp, pid, type, current->uid, current->euid, force);
279         return 0;
280 }
281 EXPORT_SYMBOL(__f_setown);
282
283 int f_setown(struct file *filp, unsigned long arg, int force)
284 {
285         enum pid_type type;
286         struct pid *pid;
287         int who = arg;
288         int result;
289         type = PIDTYPE_PID;
290         if (who < 0) {
291                 type = PIDTYPE_PGID;
292                 who = -who;
293         }
294         rcu_read_lock();
295         pid = find_pid(who);
296         result = __f_setown(filp, pid, type, force);
297         rcu_read_unlock();
298         return result;
299 }
300 EXPORT_SYMBOL(f_setown);
301
302 void f_delown(struct file *filp)
303 {
304         f_modown(filp, NULL, PIDTYPE_PID, 0, 0, 1);
305 }
306
307 pid_t f_getown(struct file *filp)
308 {
309         pid_t pid;
310         read_lock(&filp->f_owner.lock);
311         pid = pid_nr(filp->f_owner.pid);
312         if (filp->f_owner.pid_type == PIDTYPE_PGID)
313                 pid = -pid;
314         read_unlock(&filp->f_owner.lock);
315         return pid;
316 }
317
318 static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
319                 struct file *filp)
320 {
321         long err = -EINVAL;
322
323         switch (cmd) {
324         case F_DUPFD:
325         case F_DUPFD_CLOEXEC:
326                 get_file(filp);
327                 err = dupfd(filp, arg, cmd == F_DUPFD_CLOEXEC);
328                 break;
329         case F_GETFD:
330                 err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
331                 break;
332         case F_SETFD:
333                 err = 0;
334                 set_close_on_exec(fd, arg & FD_CLOEXEC);
335                 break;
336         case F_GETFL:
337                 err = filp->f_flags;
338                 break;
339         case F_SETFL:
340                 err = setfl(fd, filp, arg);
341                 break;
342         case F_GETLK:
343                 err = fcntl_getlk(filp, (struct flock __user *) arg);
344                 break;
345         case F_SETLK:
346         case F_SETLKW:
347                 err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
348                 break;
349         case F_GETOWN:
350                 /*
351                  * XXX If f_owner is a process group, the
352                  * negative return value will get converted
353                  * into an error.  Oops.  If we keep the
354                  * current syscall conventions, the only way
355                  * to fix this will be in libc.
356                  */
357                 err = f_getown(filp);
358                 force_successful_syscall_return();
359                 break;
360         case F_SETOWN:
361                 err = f_setown(filp, arg, 1);
362                 break;
363         case F_GETSIG:
364                 err = filp->f_owner.signum;
365                 break;
366         case F_SETSIG:
367                 /* arg == 0 restores default behaviour. */
368                 if (!valid_signal(arg)) {
369                         break;
370                 }
371                 err = 0;
372                 filp->f_owner.signum = arg;
373                 break;
374         case F_GETLEASE:
375                 err = fcntl_getlease(filp);
376                 break;
377         case F_SETLEASE:
378                 err = fcntl_setlease(fd, filp, arg);
379                 break;
380         case F_NOTIFY:
381                 err = fcntl_dirnotify(fd, filp, arg);
382                 break;
383         default:
384                 break;
385         }
386         return err;
387 }
388
389 asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
390 {       
391         struct file *filp;
392         long err = -EBADF;
393
394         filp = fget(fd);
395         if (!filp)
396                 goto out;
397
398         err = security_file_fcntl(filp, cmd, arg);
399         if (err) {
400                 fput(filp);
401                 return err;
402         }
403
404         err = do_fcntl(fd, cmd, arg, filp);
405
406         fput(filp);
407 out:
408         return err;
409 }
410
411 #if BITS_PER_LONG == 32
412 asmlinkage long sys_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
413 {       
414         struct file * filp;
415         long err;
416
417         err = -EBADF;
418         filp = fget(fd);
419         if (!filp)
420                 goto out;
421
422         err = security_file_fcntl(filp, cmd, arg);
423         if (err) {
424                 fput(filp);
425                 return err;
426         }
427         err = -EBADF;
428         
429         switch (cmd) {
430                 case F_GETLK64:
431                         err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
432                         break;
433                 case F_SETLK64:
434                 case F_SETLKW64:
435                         err = fcntl_setlk64(fd, filp, cmd,
436                                         (struct flock64 __user *) arg);
437                         break;
438                 default:
439                         err = do_fcntl(fd, cmd, arg, filp);
440                         break;
441         }
442         fput(filp);
443 out:
444         return err;
445 }
446 #endif
447
448 /* Table to convert sigio signal codes into poll band bitmaps */
449
450 static const long band_table[NSIGPOLL] = {
451         POLLIN | POLLRDNORM,                    /* POLL_IN */
452         POLLOUT | POLLWRNORM | POLLWRBAND,      /* POLL_OUT */
453         POLLIN | POLLRDNORM | POLLMSG,          /* POLL_MSG */
454         POLLERR,                                /* POLL_ERR */
455         POLLPRI | POLLRDBAND,                   /* POLL_PRI */
456         POLLHUP | POLLERR                       /* POLL_HUP */
457 };
458
459 static inline int sigio_perm(struct task_struct *p,
460                              struct fown_struct *fown, int sig)
461 {
462         return (((fown->euid == 0) ||
463                  (fown->euid == p->suid) || (fown->euid == p->uid) ||
464                  (fown->uid == p->suid) || (fown->uid == p->uid)) &&
465                 !security_file_send_sigiotask(p, fown, sig));
466 }
467
468 static void send_sigio_to_task(struct task_struct *p,
469                                struct fown_struct *fown, 
470                                int fd,
471                                int reason)
472 {
473         if (!sigio_perm(p, fown, fown->signum))
474                 return;
475
476         switch (fown->signum) {
477                 siginfo_t si;
478                 default:
479                         /* Queue a rt signal with the appropriate fd as its
480                            value.  We use SI_SIGIO as the source, not 
481                            SI_KERNEL, since kernel signals always get 
482                            delivered even if we can't queue.  Failure to
483                            queue in this case _should_ be reported; we fall
484                            back to SIGIO in that case. --sct */
485                         si.si_signo = fown->signum;
486                         si.si_errno = 0;
487                         si.si_code  = reason;
488                         /* Make sure we are called with one of the POLL_*
489                            reasons, otherwise we could leak kernel stack into
490                            userspace.  */
491                         BUG_ON((reason & __SI_MASK) != __SI_POLL);
492                         if (reason - POLL_IN >= NSIGPOLL)
493                                 si.si_band  = ~0L;
494                         else
495                                 si.si_band = band_table[reason - POLL_IN];
496                         si.si_fd    = fd;
497                         if (!group_send_sig_info(fown->signum, &si, p))
498                                 break;
499                 /* fall-through: fall back on the old plain SIGIO signal */
500                 case 0:
501                         group_send_sig_info(SIGIO, SEND_SIG_PRIV, p);
502         }
503 }
504
505 void send_sigio(struct fown_struct *fown, int fd, int band)
506 {
507         struct task_struct *p;
508         enum pid_type type;
509         struct pid *pid;
510         
511         read_lock(&fown->lock);
512         type = fown->pid_type;
513         pid = fown->pid;
514         if (!pid)
515                 goto out_unlock_fown;
516         
517         read_lock(&tasklist_lock);
518         do_each_pid_task(pid, type, p) {
519                 send_sigio_to_task(p, fown, fd, band);
520         } while_each_pid_task(pid, type, p);
521         read_unlock(&tasklist_lock);
522  out_unlock_fown:
523         read_unlock(&fown->lock);
524 }
525
526 static void send_sigurg_to_task(struct task_struct *p,
527                                 struct fown_struct *fown)
528 {
529         if (sigio_perm(p, fown, SIGURG))
530                 group_send_sig_info(SIGURG, SEND_SIG_PRIV, p);
531 }
532
533 int send_sigurg(struct fown_struct *fown)
534 {
535         struct task_struct *p;
536         enum pid_type type;
537         struct pid *pid;
538         int ret = 0;
539         
540         read_lock(&fown->lock);
541         type = fown->pid_type;
542         pid = fown->pid;
543         if (!pid)
544                 goto out_unlock_fown;
545
546         ret = 1;
547         
548         read_lock(&tasklist_lock);
549         do_each_pid_task(pid, type, p) {
550                 send_sigurg_to_task(p, fown);
551         } while_each_pid_task(pid, type, p);
552         read_unlock(&tasklist_lock);
553  out_unlock_fown:
554         read_unlock(&fown->lock);
555         return ret;
556 }
557
558 static DEFINE_RWLOCK(fasync_lock);
559 static struct kmem_cache *fasync_cache __read_mostly;
560
561 /*
562  * fasync_helper() is used by some character device drivers (mainly mice)
563  * to set up the fasync queue. It returns negative on error, 0 if it did
564  * no changes and positive if it added/deleted the entry.
565  */
566 int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
567 {
568         struct fasync_struct *fa, **fp;
569         struct fasync_struct *new = NULL;
570         int result = 0;
571
572         if (on) {
573                 new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
574                 if (!new)
575                         return -ENOMEM;
576         }
577         write_lock_irq(&fasync_lock);
578         for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
579                 if (fa->fa_file == filp) {
580                         if(on) {
581                                 fa->fa_fd = fd;
582                                 kmem_cache_free(fasync_cache, new);
583                         } else {
584                                 *fp = fa->fa_next;
585                                 kmem_cache_free(fasync_cache, fa);
586                                 result = 1;
587                         }
588                         goto out;
589                 }
590         }
591
592         if (on) {
593                 new->magic = FASYNC_MAGIC;
594                 new->fa_file = filp;
595                 new->fa_fd = fd;
596                 new->fa_next = *fapp;
597                 *fapp = new;
598                 result = 1;
599         }
600 out:
601         write_unlock_irq(&fasync_lock);
602         return result;
603 }
604
605 EXPORT_SYMBOL(fasync_helper);
606
607 void __kill_fasync(struct fasync_struct *fa, int sig, int band)
608 {
609         while (fa) {
610                 struct fown_struct * fown;
611                 if (fa->magic != FASYNC_MAGIC) {
612                         printk(KERN_ERR "kill_fasync: bad magic number in "
613                                "fasync_struct!\n");
614                         return;
615                 }
616                 fown = &fa->fa_file->f_owner;
617                 /* Don't send SIGURG to processes which have not set a
618                    queued signum: SIGURG has its own default signalling
619                    mechanism. */
620                 if (!(sig == SIGURG && fown->signum == 0))
621                         send_sigio(fown, fa->fa_fd, band);
622                 fa = fa->fa_next;
623         }
624 }
625
626 EXPORT_SYMBOL(__kill_fasync);
627
628 void kill_fasync(struct fasync_struct **fp, int sig, int band)
629 {
630         /* First a quick test without locking: usually
631          * the list is empty.
632          */
633         if (*fp) {
634                 read_lock(&fasync_lock);
635                 /* reread *fp after obtaining the lock */
636                 __kill_fasync(*fp, sig, band);
637                 read_unlock(&fasync_lock);
638         }
639 }
640 EXPORT_SYMBOL(kill_fasync);
641
642 static int __init fasync_init(void)
643 {
644         fasync_cache = kmem_cache_create("fasync_cache",
645                 sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
646         return 0;
647 }
648
649 module_init(fasync_init)