~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/fcntl.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp