Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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/fdtable.h>
 13 #include <linux/capability.h>
 14 #include <linux/dnotify.h>
 15 #include <linux/slab.h>
 16 #include <linux/module.h>
 17 #include <linux/pipe_fs_i.h>
 18 #include <linux/security.h>
 19 #include <linux/ptrace.h>
 20 #include <linux/signal.h>
 21 #include <linux/rcupdate.h>
 22 #include <linux/pid_namespace.h>
 23 
 24 #include <asm/poll.h>
 25 #include <asm/siginfo.h>
 26 #include <asm/uaccess.h>
 27 
 28 void set_close_on_exec(unsigned int fd, int flag)
 29 {
 30         struct files_struct *files = current->files;
 31         struct fdtable *fdt;
 32         spin_lock(&files->file_lock);
 33         fdt = files_fdtable(files);
 34         if (flag)
 35                 FD_SET(fd, fdt->close_on_exec);
 36         else
 37                 FD_CLR(fd, fdt->close_on_exec);
 38         spin_unlock(&files->file_lock);
 39 }
 40 
 41 static int get_close_on_exec(unsigned int fd)
 42 {
 43         struct files_struct *files = current->files;
 44         struct fdtable *fdt;
 45         int res;
 46         rcu_read_lock();
 47         fdt = files_fdtable(files);
 48         res = FD_ISSET(fd, fdt->close_on_exec);
 49         rcu_read_unlock();
 50         return res;
 51 }
 52 
 53 SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
 54 {
 55         int err = -EBADF;
 56         struct file * file, *tofree;
 57         struct files_struct * files = current->files;
 58         struct fdtable *fdt;
 59 
 60         if ((flags & ~O_CLOEXEC) != 0)
 61                 return -EINVAL;
 62 
 63         if (unlikely(oldfd == newfd))
 64                 return -EINVAL;
 65 
 66         spin_lock(&files->file_lock);
 67         err = expand_files(files, newfd);
 68         file = fcheck(oldfd);
 69         if (unlikely(!file))
 70                 goto Ebadf;
 71         if (unlikely(err < 0)) {
 72                 if (err == -EMFILE)
 73                         goto Ebadf;
 74                 goto out_unlock;
 75         }
 76         /*
 77          * We need to detect attempts to do dup2() over allocated but still
 78          * not finished descriptor.  NB: OpenBSD avoids that at the price of
 79          * extra work in their equivalent of fget() - they insert struct
 80          * file immediately after grabbing descriptor, mark it larval if
 81          * more work (e.g. actual opening) is needed and make sure that
 82          * fget() treats larval files as absent.  Potentially interesting,
 83          * but while extra work in fget() is trivial, locking implications
 84          * and amount of surgery on open()-related paths in VFS are not.
 85          * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
 86          * deadlocks in rather amusing ways, AFAICS.  All of that is out of
 87          * scope of POSIX or SUS, since neither considers shared descriptor
 88          * tables and this condition does not arise without those.
 89          */
 90         err = -EBUSY;
 91         fdt = files_fdtable(files);
 92         tofree = fdt->fd[newfd];
 93         if (!tofree && FD_ISSET(newfd, fdt->open_fds))
 94                 goto out_unlock;
 95         get_file(file);
 96         rcu_assign_pointer(fdt->fd[newfd], file);
 97         FD_SET(newfd, fdt->open_fds);
 98         if (flags & O_CLOEXEC)
 99                 FD_SET(newfd, fdt->close_on_exec);
100         else
101                 FD_CLR(newfd, fdt->close_on_exec);
102         spin_unlock(&files->file_lock);
103 
104         if (tofree)
105                 filp_close(tofree, files);
106 
107         return newfd;
108 
109 Ebadf:
110         err = -EBADF;
111 out_unlock:
112         spin_unlock(&files->file_lock);
113         return err;
114 }
115 
116 SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
117 {
118         if (unlikely(newfd == oldfd)) { /* corner case */
119                 struct files_struct *files = current->files;
120                 int retval = oldfd;
121 
122                 rcu_read_lock();
123                 if (!fcheck_files(files, oldfd))
124                         retval = -EBADF;
125                 rcu_read_unlock();
126                 return retval;
127         }
128         return sys_dup3(oldfd, newfd, 0);
129 }
130 
131 SYSCALL_DEFINE1(dup, unsigned int, fildes)
132 {
133         int ret = -EBADF;
134         struct file *file = fget_raw(fildes);
135 
136         if (file) {
137                 ret = get_unused_fd();
138                 if (ret >= 0)
139                         fd_install(ret, file);
140                 else
141                         fput(file);
142         }
143         return ret;
144 }
145 
146 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
147 
148 static int setfl(int fd, struct file * filp, unsigned long arg)
149 {
150         struct inode * inode = filp->f_path.dentry->d_inode;
151         int error = 0;
152 
153         /*
154          * O_APPEND cannot be cleared if the file is marked as append-only
155          * and the file is open for write.
156          */
157         if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
158                 return -EPERM;
159 
160         /* O_NOATIME can only be set by the owner or superuser */
161         if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
162                 if (!inode_owner_or_capable(inode))
163                         return -EPERM;
164 
165         /* required for strict SunOS emulation */
166         if (O_NONBLOCK != O_NDELAY)
167                if (arg & O_NDELAY)
168                    arg |= O_NONBLOCK;
169 
170         if (arg & O_DIRECT) {
171                 if (!filp->f_mapping || !filp->f_mapping->a_ops ||
172                         !filp->f_mapping->a_ops->direct_IO)
173                                 return -EINVAL;
174         }
175 
176         if (filp->f_op && filp->f_op->check_flags)
177                 error = filp->f_op->check_flags(arg);
178         if (error)
179                 return error;
180 
181         /*
182          * ->fasync() is responsible for setting the FASYNC bit.
183          */
184         if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
185                         filp->f_op->fasync) {
186                 error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
187                 if (error < 0)
188                         goto out;
189                 if (error > 0)
190                         error = 0;
191         }
192         spin_lock(&filp->f_lock);
193         filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
194         spin_unlock(&filp->f_lock);
195 
196  out:
197         return error;
198 }
199 
200 static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
201                      int force)
202 {
203         write_lock_irq(&filp->f_owner.lock);
204         if (force || !filp->f_owner.pid) {
205                 put_pid(filp->f_owner.pid);
206                 filp->f_owner.pid = get_pid(pid);
207                 filp->f_owner.pid_type = type;
208 
209                 if (pid) {
210                         const struct cred *cred = current_cred();
211                         filp->f_owner.uid = cred->uid;
212                         filp->f_owner.euid = cred->euid;
213                 }
214         }
215         write_unlock_irq(&filp->f_owner.lock);
216 }
217 
218 int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
219                 int force)
220 {
221         int err;
222 
223         err = security_file_set_fowner(filp);
224         if (err)
225                 return err;
226 
227         f_modown(filp, pid, type, force);
228         return 0;
229 }
230 EXPORT_SYMBOL(__f_setown);
231 
232 int f_setown(struct file *filp, unsigned long arg, int force)
233 {
234         enum pid_type type;
235         struct pid *pid;
236         int who = arg;
237         int result;
238         type = PIDTYPE_PID;
239         if (who < 0) {
240                 type = PIDTYPE_PGID;
241                 who = -who;
242         }
243         rcu_read_lock();
244         pid = find_vpid(who);
245         result = __f_setown(filp, pid, type, force);
246         rcu_read_unlock();
247         return result;
248 }
249 EXPORT_SYMBOL(f_setown);
250 
251 void f_delown(struct file *filp)
252 {
253         f_modown(filp, NULL, PIDTYPE_PID, 1);
254 }
255 
256 pid_t f_getown(struct file *filp)
257 {
258         pid_t pid;
259         read_lock(&filp->f_owner.lock);
260         pid = pid_vnr(filp->f_owner.pid);
261         if (filp->f_owner.pid_type == PIDTYPE_PGID)
262                 pid = -pid;
263         read_unlock(&filp->f_owner.lock);
264         return pid;
265 }
266 
267 static int f_setown_ex(struct file *filp, unsigned long arg)
268 {
269         struct f_owner_ex * __user owner_p = (void * __user)arg;
270         struct f_owner_ex owner;
271         struct pid *pid;
272         int type;
273         int ret;
274 
275         ret = copy_from_user(&owner, owner_p, sizeof(owner));
276         if (ret)
277                 return -EFAULT;
278 
279         switch (owner.type) {
280         case F_OWNER_TID:
281                 type = PIDTYPE_MAX;
282                 break;
283 
284         case F_OWNER_PID:
285                 type = PIDTYPE_PID;
286                 break;
287 
288         case F_OWNER_PGRP:
289                 type = PIDTYPE_PGID;
290                 break;
291 
292         default:
293                 return -EINVAL;
294         }
295 
296         rcu_read_lock();
297         pid = find_vpid(owner.pid);
298         if (owner.pid && !pid)
299                 ret = -ESRCH;
300         else
301                 ret = __f_setown(filp, pid, type, 1);
302         rcu_read_unlock();
303 
304         return ret;
305 }
306 
307 static int f_getown_ex(struct file *filp, unsigned long arg)
308 {
309         struct f_owner_ex * __user owner_p = (void * __user)arg;
310         struct f_owner_ex owner;
311         int ret = 0;
312 
313         read_lock(&filp->f_owner.lock);
314         owner.pid = pid_vnr(filp->f_owner.pid);
315         switch (filp->f_owner.pid_type) {
316         case PIDTYPE_MAX:
317                 owner.type = F_OWNER_TID;
318                 break;
319 
320         case PIDTYPE_PID:
321                 owner.type = F_OWNER_PID;
322                 break;
323 
324         case PIDTYPE_PGID:
325                 owner.type = F_OWNER_PGRP;
326                 break;
327 
328         default:
329                 WARN_ON(1);
330                 ret = -EINVAL;
331                 break;
332         }
333         read_unlock(&filp->f_owner.lock);
334 
335         if (!ret) {
336                 ret = copy_to_user(owner_p, &owner, sizeof(owner));
337                 if (ret)
338                         ret = -EFAULT;
339         }
340         return ret;
341 }
342 
343 static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
344                 struct file *filp)
345 {
346         long err = -EINVAL;
347 
348         switch (cmd) {
349         case F_DUPFD:
350         case F_DUPFD_CLOEXEC:
351                 if (arg >= rlimit(RLIMIT_NOFILE))
352                         break;
353                 err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
354                 if (err >= 0) {
355                         get_file(filp);
356                         fd_install(err, filp);
357                 }
358                 break;
359         case F_GETFD:
360                 err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
361                 break;
362         case F_SETFD:
363                 err = 0;
364                 set_close_on_exec(fd, arg & FD_CLOEXEC);
365                 break;
366         case F_GETFL:
367                 err = filp->f_flags;
368                 break;
369         case F_SETFL:
370                 err = setfl(fd, filp, arg);
371                 break;
372         case F_GETLK:
373                 err = fcntl_getlk(filp, (struct flock __user *) arg);
374                 break;
375         case F_SETLK:
376         case F_SETLKW:
377                 err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
378                 break;
379         case F_GETOWN:
380                 /*
381                  * XXX If f_owner is a process group, the
382                  * negative return value will get converted
383                  * into an error.  Oops.  If we keep the
384                  * current syscall conventions, the only way
385                  * to fix this will be in libc.
386                  */
387                 err = f_getown(filp);
388                 force_successful_syscall_return();
389                 break;
390         case F_SETOWN:
391                 err = f_setown(filp, arg, 1);
392                 break;
393         case F_GETOWN_EX:
394                 err = f_getown_ex(filp, arg);
395                 break;
396         case F_SETOWN_EX:
397                 err = f_setown_ex(filp, arg);
398                 break;
399         case F_GETSIG:
400                 err = filp->f_owner.signum;
401                 break;
402         case F_SETSIG:
403                 /* arg == 0 restores default behaviour. */
404                 if (!valid_signal(arg)) {
405                         break;
406                 }
407                 err = 0;
408                 filp->f_owner.signum = arg;
409                 break;
410         case F_GETLEASE:
411                 err = fcntl_getlease(filp);
412                 break;
413         case F_SETLEASE:
414                 err = fcntl_setlease(fd, filp, arg);
415                 break;
416         case F_NOTIFY:
417                 err = fcntl_dirnotify(fd, filp, arg);
418                 break;
419         case F_SETPIPE_SZ:
420         case F_GETPIPE_SZ:
421                 err = pipe_fcntl(filp, cmd, arg);
422                 break;
423         default:
424                 break;
425         }
426         return err;
427 }
428 
429 static int check_fcntl_cmd(unsigned cmd)
430 {
431         switch (cmd) {
432         case F_DUPFD:
433         case F_DUPFD_CLOEXEC:
434         case F_GETFD:
435         case F_SETFD:
436         case F_GETFL:
437                 return 1;
438         }
439         return 0;
440 }
441 
442 SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
443 {       
444         struct file *filp;
445         long err = -EBADF;
446 
447         filp = fget_raw(fd);
448         if (!filp)
449                 goto out;
450 
451         if (unlikely(filp->f_mode & FMODE_PATH)) {
452                 if (!check_fcntl_cmd(cmd)) {
453                         fput(filp);
454                         goto out;
455                 }
456         }
457 
458         err = security_file_fcntl(filp, cmd, arg);
459         if (err) {
460                 fput(filp);
461                 return err;
462         }
463 
464         err = do_fcntl(fd, cmd, arg, filp);
465 
466         fput(filp);
467 out:
468         return err;
469 }
470 
471 #if BITS_PER_LONG == 32
472 SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
473                 unsigned long, arg)
474 {       
475         struct file * filp;
476         long err;
477 
478         err = -EBADF;
479         filp = fget_raw(fd);
480         if (!filp)
481                 goto out;
482 
483         if (unlikely(filp->f_mode & FMODE_PATH)) {
484                 if (!check_fcntl_cmd(cmd)) {
485                         fput(filp);
486                         goto out;
487                 }
488         }
489 
490         err = security_file_fcntl(filp, cmd, arg);
491         if (err) {
492                 fput(filp);
493                 return err;
494         }
495         err = -EBADF;
496         
497         switch (cmd) {
498                 case F_GETLK64:
499                         err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
500                         break;
501                 case F_SETLK64:
502                 case F_SETLKW64:
503                         err = fcntl_setlk64(fd, filp, cmd,
504                                         (struct flock64 __user *) arg);
505                         break;
506                 default:
507                         err = do_fcntl(fd, cmd, arg, filp);
508                         break;
509         }
510         fput(filp);
511 out:
512         return err;
513 }
514 #endif
515 
516 /* Table to convert sigio signal codes into poll band bitmaps */
517 
518 static const long band_table[NSIGPOLL] = {
519         POLLIN | POLLRDNORM,                    /* POLL_IN */
520         POLLOUT | POLLWRNORM | POLLWRBAND,      /* POLL_OUT */
521         POLLIN | POLLRDNORM | POLLMSG,          /* POLL_MSG */
522         POLLERR,                                /* POLL_ERR */
523         POLLPRI | POLLRDBAND,                   /* POLL_PRI */
524         POLLHUP | POLLERR                       /* POLL_HUP */
525 };
526 
527 static inline int sigio_perm(struct task_struct *p,
528                              struct fown_struct *fown, int sig)
529 {
530         const struct cred *cred;
531         int ret;
532 
533         rcu_read_lock();
534         cred = __task_cred(p);
535         ret = ((fown->euid == 0 ||
536                 fown->euid == cred->suid || fown->euid == cred->uid ||
537                 fown->uid  == cred->suid || fown->uid  == cred->uid) &&
538                !security_file_send_sigiotask(p, fown, sig));
539         rcu_read_unlock();
540         return ret;
541 }
542 
543 static void send_sigio_to_task(struct task_struct *p,
544                                struct fown_struct *fown,
545                                int fd, int reason, int group)
546 {
547         /*
548          * F_SETSIG can change ->signum lockless in parallel, make
549          * sure we read it once and use the same value throughout.
550          */
551         int signum = ACCESS_ONCE(fown->signum);
552 
553         if (!sigio_perm(p, fown, signum))
554                 return;
555 
556         switch (signum) {
557                 siginfo_t si;
558                 default:
559                         /* Queue a rt signal with the appropriate fd as its
560                            value.  We use SI_SIGIO as the source, not 
561                            SI_KERNEL, since kernel signals always get 
562                            delivered even if we can't queue.  Failure to
563                            queue in this case _should_ be reported; we fall
564                            back to SIGIO in that case. --sct */
565                         si.si_signo = signum;
566                         si.si_errno = 0;
567                         si.si_code  = reason;
568                         /* Make sure we are called with one of the POLL_*
569                            reasons, otherwise we could leak kernel stack into
570                            userspace.  */
571                         BUG_ON((reason & __SI_MASK) != __SI_POLL);
572                         if (reason - POLL_IN >= NSIGPOLL)
573                                 si.si_band  = ~0L;
574                         else
575                                 si.si_band = band_table[reason - POLL_IN];
576                         si.si_fd    = fd;
577                         if (!do_send_sig_info(signum, &si, p, group))
578                                 break;
579                 /* fall-through: fall back on the old plain SIGIO signal */
580                 case 0:
581                         do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
582         }
583 }
584 
585 void send_sigio(struct fown_struct *fown, int fd, int band)
586 {
587         struct task_struct *p;
588         enum pid_type type;
589         struct pid *pid;
590         int group = 1;
591         
592         read_lock(&fown->lock);
593 
594         type = fown->pid_type;
595         if (type == PIDTYPE_MAX) {
596                 group = 0;
597                 type = PIDTYPE_PID;
598         }
599 
600         pid = fown->pid;
601         if (!pid)
602                 goto out_unlock_fown;
603         
604         read_lock(&tasklist_lock);
605         do_each_pid_task(pid, type, p) {
606                 send_sigio_to_task(p, fown, fd, band, group);
607         } while_each_pid_task(pid, type, p);
608         read_unlock(&tasklist_lock);
609  out_unlock_fown:
610         read_unlock(&fown->lock);
611 }
612 
613 static void send_sigurg_to_task(struct task_struct *p,
614                                 struct fown_struct *fown, int group)
615 {
616         if (sigio_perm(p, fown, SIGURG))
617                 do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
618 }
619 
620 int send_sigurg(struct fown_struct *fown)
621 {
622         struct task_struct *p;
623         enum pid_type type;
624         struct pid *pid;
625         int group = 1;
626         int ret = 0;
627         
628         read_lock(&fown->lock);
629 
630         type = fown->pid_type;
631         if (type == PIDTYPE_MAX) {
632                 group = 0;
633                 type = PIDTYPE_PID;
634         }
635 
636         pid = fown->pid;
637         if (!pid)
638                 goto out_unlock_fown;
639 
640         ret = 1;
641         
642         read_lock(&tasklist_lock);
643         do_each_pid_task(pid, type, p) {
644                 send_sigurg_to_task(p, fown, group);
645         } while_each_pid_task(pid, type, p);
646         read_unlock(&tasklist_lock);
647  out_unlock_fown:
648         read_unlock(&fown->lock);
649         return ret;
650 }
651 
652 static DEFINE_SPINLOCK(fasync_lock);
653 static struct kmem_cache *fasync_cache __read_mostly;
654 
655 static void fasync_free_rcu(struct rcu_head *head)
656 {
657         kmem_cache_free(fasync_cache,
658                         container_of(head, struct fasync_struct, fa_rcu));
659 }
660 
661 /*
662  * Remove a fasync entry. If successfully removed, return
663  * positive and clear the FASYNC flag. If no entry exists,
664  * do nothing and return 0.
665  *
666  * NOTE! It is very important that the FASYNC flag always
667  * match the state "is the filp on a fasync list".
668  *
669  */
670 int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
671 {
672         struct fasync_struct *fa, **fp;
673         int result = 0;
674 
675         spin_lock(&filp->f_lock);
676         spin_lock(&fasync_lock);
677         for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
678                 if (fa->fa_file != filp)
679                         continue;
680 
681                 spin_lock_irq(&fa->fa_lock);
682                 fa->fa_file = NULL;
683                 spin_unlock_irq(&fa->fa_lock);
684 
685                 *fp = fa->fa_next;
686                 call_rcu(&fa->fa_rcu, fasync_free_rcu);
687                 filp->f_flags &= ~FASYNC;
688                 result = 1;
689                 break;
690         }
691         spin_unlock(&fasync_lock);
692         spin_unlock(&filp->f_lock);
693         return result;
694 }
695 
696 struct fasync_struct *fasync_alloc(void)
697 {
698         return kmem_cache_alloc(fasync_cache, GFP_KERNEL);
699 }
700 
701 /*
702  * NOTE! This can be used only for unused fasync entries:
703  * entries that actually got inserted on the fasync list
704  * need to be released by rcu - see fasync_remove_entry.
705  */
706 void fasync_free(struct fasync_struct *new)
707 {
708         kmem_cache_free(fasync_cache, new);
709 }
710 
711 /*
712  * Insert a new entry into the fasync list.  Return the pointer to the
713  * old one if we didn't use the new one.
714  *
715  * NOTE! It is very important that the FASYNC flag always
716  * match the state "is the filp on a fasync list".
717  */
718 struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
719 {
720         struct fasync_struct *fa, **fp;
721 
722         spin_lock(&filp->f_lock);
723         spin_lock(&fasync_lock);
724         for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
725                 if (fa->fa_file != filp)
726                         continue;
727 
728                 spin_lock_irq(&fa->fa_lock);
729                 fa->fa_fd = fd;
730                 spin_unlock_irq(&fa->fa_lock);
731                 goto out;
732         }
733 
734         spin_lock_init(&new->fa_lock);
735         new->magic = FASYNC_MAGIC;
736         new->fa_file = filp;
737         new->fa_fd = fd;
738         new->fa_next = *fapp;
739         rcu_assign_pointer(*fapp, new);
740         filp->f_flags |= FASYNC;
741 
742 out:
743         spin_unlock(&fasync_lock);
744         spin_unlock(&filp->f_lock);
745         return fa;
746 }
747 
748 /*
749  * Add a fasync entry. Return negative on error, positive if
750  * added, and zero if did nothing but change an existing one.
751  */
752 static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
753 {
754         struct fasync_struct *new;
755 
756         new = fasync_alloc();
757         if (!new)
758                 return -ENOMEM;
759 
760         /*
761          * fasync_insert_entry() returns the old (update) entry if
762          * it existed.
763          *
764          * So free the (unused) new entry and return 0 to let the
765          * caller know that we didn't add any new fasync entries.
766          */
767         if (fasync_insert_entry(fd, filp, fapp, new)) {
768                 fasync_free(new);
769                 return 0;
770         }
771 
772         return 1;
773 }
774 
775 /*
776  * fasync_helper() is used by almost all character device drivers
777  * to set up the fasync queue, and for regular files by the file
778  * lease code. It returns negative on error, 0 if it did no changes
779  * and positive if it added/deleted the entry.
780  */
781 int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
782 {
783         if (!on)
784                 return fasync_remove_entry(filp, fapp);
785         return fasync_add_entry(fd, filp, fapp);
786 }
787 
788 EXPORT_SYMBOL(fasync_helper);
789 
790 /*
791  * rcu_read_lock() is held
792  */
793 static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
794 {
795         while (fa) {
796                 struct fown_struct *fown;
797                 unsigned long flags;
798 
799                 if (fa->magic != FASYNC_MAGIC) {
800                         printk(KERN_ERR "kill_fasync: bad magic number in "
801                                "fasync_struct!\n");
802                         return;
803                 }
804                 spin_lock_irqsave(&fa->fa_lock, flags);
805                 if (fa->fa_file) {
806                         fown = &fa->fa_file->f_owner;
807                         /* Don't send SIGURG to processes which have not set a
808                            queued signum: SIGURG has its own default signalling
809                            mechanism. */
810                         if (!(sig == SIGURG && fown->signum == 0))
811                                 send_sigio(fown, fa->fa_fd, band);
812                 }
813                 spin_unlock_irqrestore(&fa->fa_lock, flags);
814                 fa = rcu_dereference(fa->fa_next);
815         }
816 }
817 
818 void kill_fasync(struct fasync_struct **fp, int sig, int band)
819 {
820         /* First a quick test without locking: usually
821          * the list is empty.
822          */
823         if (*fp) {
824                 rcu_read_lock();
825                 kill_fasync_rcu(rcu_dereference(*fp), sig, band);
826                 rcu_read_unlock();
827         }
828 }
829 EXPORT_SYMBOL(kill_fasync);
830 
831 static int __init fcntl_init(void)
832 {
833         /*
834          * Please add new bits here to ensure allocation uniqueness.
835          * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
836          * is defined as O_NONBLOCK on some platforms and not on others.
837          */
838         BUILD_BUG_ON(19 - 1 /* for O_RDONLY being 0 */ != HWEIGHT32(
839                 O_RDONLY        | O_WRONLY      | O_RDWR        |
840                 O_CREAT         | O_EXCL        | O_NOCTTY      |
841                 O_TRUNC         | O_APPEND      | /* O_NONBLOCK | */
842                 __O_SYNC        | O_DSYNC       | FASYNC        |
843                 O_DIRECT        | O_LARGEFILE   | O_DIRECTORY   |
844                 O_NOFOLLOW      | O_NOATIME     | O_CLOEXEC     |
845                 __FMODE_EXEC    | O_PATH
846                 ));
847 
848         fasync_cache = kmem_cache_create("fasync_cache",
849                 sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
850         return 0;
851 }
852 
853 module_init(fcntl_init)
854 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us